From aa0ee2d2f204394bddc2ac24ee9687e0f90c2ba7 Mon Sep 17 00:00:00 2001 From: antoineatrhea Date: Thu, 21 Mar 2024 14:37:47 +0100 Subject: [PATCH] Fix #262: Moved from Newtonsoft.Json to System.Text.Json --- CDP4-SDK.sln | 6 + CDP4-SDK.sln.DotSettings | 2 +- CDP4Dal.NetCore.Tests/DAL/DalTestFixture.cs | 40 +- .../OperationContainerTestFixture.cs | 40 +- .../Operations/OperationTestFixture.cs | 28 +- .../Operations/PostOperationTestFixture.cs | 36 +- .../Operations/ThingTransactionTestFixture.cs | 40 +- CDP4Dal.NetCore.Tests/SessionTestFixture.cs | 129 +- CDP4Dal.Tests/DAL/DalTestFixture.cs | 65 +- .../OperationContainerTestFixture.cs | 40 +- .../Operations/OperationTestFixture.cs | 28 +- .../Operations/PostOperationTestFixture.cs | 38 +- .../Operations/ThingTransactionTestFixture.cs | 83 +- CDP4Dal.Tests/SessionTestFixture.cs | 109 +- CDP4Dal/DAL/Dal.cs | 41 +- CDP4Dal/DAL/IDal.cs | 37 +- .../InvalidOperationContainerException.cs | 24 +- .../InvalidOperationKindException.cs | 26 +- CDP4Dal/ISession.cs | 26 +- CDP4Dal/Operations/IThingTransaction.cs | 31 +- CDP4Dal/Operations/LongRunningTaskResult.cs | 4 +- CDP4Dal/Operations/OperationContainer.cs | 39 +- CDP4Dal/Operations/OperationKindExtensions.cs | 28 +- CDP4Dal/Operations/ThingTransaction.cs | 137 +- CDP4Dal/Session.cs | 25 +- .../Protocol}/Operations/Operation.cs | 28 +- .../Protocol}/Operations/OperationKind.cs | 30 +- .../Protocol}/Operations/PostOperation.cs | 29 +- .../{ => Protocol}/Tasks/CometTask.cs | 10 +- .../{ => Protocol}/Tasks/StatusKind.cs | 29 +- .../CDP4DalJsonSerializer.csproj | 44 + .../Cdp4DalJsonSerializer.cs | 86 + .../Extensions/JsonElementExtensions.cs | 70 + .../PostOperationJsonConverter.cs | 150 ++ .../JsonFileDalTestFixture.cs | 23 +- .../JsonFileDalTestFixture.cs | 31 +- CDP4JsonFileDal/CDP4JsonFileDal.csproj | 1 + CDP4JsonFileDal/JsonFileDal.cs | 35 +- .../Helper/SerializerHelperTestFixture.cs | 50 +- .../JsonSerializerTestFixture.cs | 33 +- .../Helper/SerializerHelperTestFixture.cs | 52 +- .../JsonSerializerTestFixture.cs | 36 +- .../PostOperation/CdpPostOperation.cs | 33 +- .../ActionItemResolver.cs | 28 +- .../ActualFiniteStateListResolver.cs | 6 +- .../ActualFiniteStateResolver.cs | 6 +- .../AutoGenDtoDeserializer/AliasResolver.cs | 10 +- .../AndExpressionResolver.cs | 4 +- .../ApprovalResolver.cs | 16 +- .../ArrayParameterTypeResolver.cs | 16 +- .../BinaryNoteResolver.cs | 16 +- .../BinaryRelationshipResolver.cs | 12 +- .../BinaryRelationshipRuleResolver.cs | 20 +- .../AutoGenDtoDeserializer/BookResolver.cs | 12 +- .../BooleanParameterTypeResolver.cs | 12 +- .../AutoGenDtoDeserializer/BoundsResolver.cs | 14 +- .../BuiltInRuleVerificationResolver.cs | 10 +- .../CategoryResolver.cs | 12 +- .../ChangeProposalResolver.cs | 24 +- .../ChangeRequestResolver.cs | 22 +- .../CitationResolver.cs | 14 +- .../AutoGenDtoDeserializer/ColorResolver.cs | 12 +- .../CommonFileStoreResolver.cs | 10 +- .../CompoundParameterTypeResolver.cs | 14 +- .../ConstantResolver.cs | 12 +- .../ContractChangeNoticeResolver.cs | 24 +- .../CyclicRatioScaleResolver.cs | 28 +- .../DateParameterTypeResolver.cs | 12 +- .../DateTimeParameterTypeResolver.cs | 12 +- .../DecompositionRuleResolver.cs | 14 +- .../DefinitionResolver.cs | 8 +- ...ependentParameterTypeAssignmentResolver.cs | 6 +- .../DerivedQuantityKindResolver.cs | 16 +- .../DerivedUnitResolver.cs | 10 +- .../DiagramCanvasResolver.cs | 8 +- .../DiagramEdgeResolver.cs | 10 +- .../DiagramObjectResolver.cs | 10 +- .../DomainFileStoreResolver.cs | 12 +- .../DomainOfExpertiseGroupResolver.cs | 10 +- .../DomainOfExpertiseResolver.cs | 10 +- .../ElementDefinitionResolver.cs | 10 +- .../ElementUsageResolver.cs | 14 +- .../EmailAddressResolver.cs | 8 +- ...ineeringModelDataDiscussionItemResolver.cs | 12 +- .../EngineeringModelDataNoteResolver.cs | 12 +- .../EngineeringModelResolver.cs | 8 +- .../EngineeringModelSetupResolver.cs | 14 +- .../EnumerationParameterTypeResolver.cs | 14 +- .../EnumerationValueDefinitionResolver.cs | 8 +- .../ExclusiveOrExpressionResolver.cs | 4 +- .../ExternalIdentifierMapResolver.cs | 14 +- .../AutoGenDtoDeserializer/FileResolver.cs | 6 +- .../FileRevisionResolver.cs | 12 +- .../FileTypeResolver.cs | 12 +- .../AutoGenDtoDeserializer/FolderResolver.cs | 12 +- .../GlossaryResolver.cs | 10 +- .../AutoGenDtoDeserializer/GoalResolver.cs | 8 +- .../HyperLinkResolver.cs | 10 +- .../IdCorrespondenceResolver.cs | 8 +- ...ependentParameterTypeAssignmentResolver.cs | 6 +- .../IntervalScaleResolver.cs | 26 +- .../IterationResolver.cs | 6 +- .../IterationSetupResolver.cs | 14 +- .../LinearConversionUnitResolver.cs | 14 +- .../LogEntryChangelogItemResolver.cs | 10 +- .../LogarithmicScaleResolver.cs | 34 +- .../MappingToReferenceScaleResolver.cs | 8 +- .../ModelLogEntryResolver.cs | 12 +- .../ModelReferenceDataLibraryResolver.cs | 8 +- .../ModellingThingReferenceResolver.cs | 8 +- .../MultiRelationshipResolver.cs | 8 +- .../MultiRelationshipRuleResolver.cs | 16 +- .../NaturalLanguageResolver.cs | 10 +- .../NestedElementResolver.cs | 8 +- .../NestedParameterResolver.cs | 14 +- .../NotExpressionResolver.cs | 6 +- .../AutoGenDtoDeserializer/OptionResolver.cs | 8 +- .../OrExpressionResolver.cs | 4 +- .../OrdinalScaleResolver.cs | 28 +- .../OrganizationResolver.cs | 10 +- .../OrganizationalParticipantResolver.cs | 6 +- .../OwnedStyleResolver.cs | 8 +- .../AutoGenDtoDeserializer/PageResolver.cs | 12 +- .../ParameterGroupResolver.cs | 6 +- .../ParameterOverrideResolver.cs | 8 +- .../ParameterOverrideValueSetResolver.cs | 8 +- .../ParameterResolver.cs | 14 +- .../ParameterSubscriptionResolver.cs | 6 +- .../ParameterSubscriptionValueSetResolver.cs | 8 +- .../ParameterTypeComponentResolver.cs | 8 +- .../ParameterValueSetResolver.cs | 6 +- .../ParameterizedCategoryRuleResolver.cs | 12 +- .../ParametricConstraintResolver.cs | 4 +- .../ParticipantPermissionResolver.cs | 10 +- .../ParticipantResolver.cs | 12 +- .../ParticipantRoleResolver.cs | 10 +- .../PersonPermissionResolver.cs | 10 +- .../AutoGenDtoDeserializer/PersonResolver.cs | 18 +- .../PersonRoleResolver.cs | 10 +- .../AutoGenDtoDeserializer/PointResolver.cs | 10 +- .../PossibleFiniteStateListResolver.cs | 10 +- .../PossibleFiniteStateResolver.cs | 8 +- .../PrefixedUnitResolver.cs | 10 +- .../PublicationResolver.cs | 6 +- .../QuantityKindFactorResolver.cs | 8 +- .../RatioScaleResolver.cs | 26 +- .../ReferenceSourceResolver.cs | 16 +- .../ReferencerRuleResolver.cs | 16 +- .../RelationalExpressionResolver.cs | 8 +- .../RelationshipParameterValueResolver.cs | 6 +- .../RequestForDeviationResolver.cs | 22 +- .../RequestForWaiverResolver.cs | 22 +- .../RequirementResolver.cs | 12 +- ...irementsContainerParameterValueResolver.cs | 6 +- .../RequirementsGroupResolver.cs | 10 +- .../RequirementsSpecificationResolver.cs | 12 +- .../ReviewItemDiscrepancyResolver.cs | 22 +- .../RuleVerificationListResolver.cs | 10 +- .../RuleViolationResolver.cs | 6 +- .../SampledFunctionParameterTypeResolver.cs | 12 +- .../ScaleReferenceQuantityValueResolver.cs | 8 +- .../ScaleValueDefinitionResolver.cs | 10 +- .../AutoGenDtoDeserializer/SectionResolver.cs | 12 +- .../SharedStyleResolver.cs | 8 +- .../SimpleParameterValueResolver.cs | 6 +- .../SimpleQuantityKindResolver.cs | 16 +- .../SimpleUnitResolver.cs | 10 +- .../SiteDirectoryDataAnnotationResolver.cs | 14 +- ...SiteDirectoryDataDiscussionItemResolver.cs | 12 +- .../SiteDirectoryResolver.cs | 12 +- .../SiteDirectoryThingReferenceResolver.cs | 8 +- .../SiteLogEntryResolver.cs | 12 +- .../SiteReferenceDataLibraryResolver.cs | 10 +- .../SolutionResolver.cs | 14 +- .../SpecializedQuantityKindResolver.cs | 18 +- .../StakeHolderValueMapResolver.cs | 8 +- .../StakeHolderValueMapSettingsResolver.cs | 4 +- .../StakeholderResolver.cs | 8 +- .../StakeholderValueResolver.cs | 8 +- .../TelephoneNumberResolver.cs | 6 +- .../AutoGenDtoDeserializer/TermResolver.cs | 10 +- .../TextParameterTypeResolver.cs | 12 +- .../TextualNoteResolver.cs | 16 +- .../TimeOfDayParameterTypeResolver.cs | 12 +- .../UnitFactorResolver.cs | 8 +- .../UnitPrefixResolver.cs | 12 +- .../UserPreferenceResolver.cs | 8 +- .../UserRuleVerificationResolver.cs | 10 +- .../ValueGroupResolver.cs | 8 +- .../ActionItemSerializer.cs | 1183 +++++++----- .../ActualFiniteStateListSerializer.cs | 603 +++--- .../ActualFiniteStateSerializer.cs | 467 +++-- .../AutoGenDtoSerializer/AliasSerializer.cs | 442 +++-- .../AndExpressionSerializer.cs | 440 +++-- .../ApprovalSerializer.cs | 472 +++-- .../ArrayParameterTypeSerializer.cs | 1129 ++++++----- .../BinaryNoteSerializer.cs | 533 ++--- .../BinaryRelationshipRuleSerializer.cs | 938 +++++---- .../BinaryRelationshipSerializer.cs | 599 +++--- .../AutoGenDtoSerializer/BookSerializer.cs | 550 +++--- .../BooleanParameterTypeSerializer.cs | 895 +++++---- .../AutoGenDtoSerializer/BoundsSerializer.cs | 450 +++-- .../BuiltInRuleVerificationSerializer.cs | 620 +++--- .../CategorySerializer.cs | 992 +++++----- .../ChangeProposalSerializer.cs | 1087 ++++++----- .../ChangeRequestSerializer.cs | 1039 +++++----- .../CitationSerializer.cs | 496 ++--- .../AutoGenDtoSerializer/ColorSerializer.cs | 469 +++-- .../CommonFileStoreSerializer.cs | 600 +++--- .../CompoundParameterTypeSerializer.cs | 1021 +++++----- .../ConstantSerializer.cs | 975 +++++----- .../ContractChangeNoticeSerializer.cs | 1087 ++++++----- .../CyclicRatioScaleSerializer.cs | 1238 ++++++------ .../DateParameterTypeSerializer.cs | 895 +++++---- .../DateTimeParameterTypeSerializer.cs | 895 +++++---- .../DecompositionRuleSerializer.cs | 983 +++++----- .../DefinitionSerializer.cs | 648 ++++--- ...endentParameterTypeAssignmentSerializer.cs | 351 ++-- .../DerivedQuantityKindSerializer.cs | 1101 ++++++----- .../DerivedUnitSerializer.cs | 836 ++++---- .../DiagramCanvasSerializer.cs | 506 ++--- .../DiagramEdgeSerializer.cs | 838 ++++---- .../DiagramObjectSerializer.cs | 781 ++++---- .../DomainFileStoreSerializer.cs | 627 +++--- .../DomainOfExpertiseGroupSerializer.cs | 846 ++++---- .../DomainOfExpertiseSerializer.cs | 846 ++++---- .../ElementDefinitionSerializer.cs | 1167 +++++------ .../ElementUsageSerializer.cs | 1064 +++++----- .../EmailAddressSerializer.cs | 415 ++-- ...eeringModelDataDiscussionItemSerializer.cs | 504 ++--- .../EngineeringModelDataNoteSerializer.cs | 626 +++--- .../EngineeringModelSerializer.cs | 901 +++++---- .../EngineeringModelSetupSerializer.cs | 1276 ++++++------ .../EnumerationParameterTypeSerializer.cs | 1025 +++++----- .../EnumerationValueDefinitionSerializer.cs | 648 ++++--- .../ExclusiveOrExpressionSerializer.cs | 440 +++-- .../ExternalIdentifierMapSerializer.cs | 674 ++++--- .../FileRevisionSerializer.cs | 647 ++++--- .../AutoGenDtoSerializer/FileSerializer.cs | 599 +++--- .../FileTypeSerializer.cs | 885 +++++---- .../AutoGenDtoSerializer/FolderSerializer.cs | 568 +++--- .../GlossarySerializer.cs | 903 +++++---- .../AutoGenDtoSerializer/GoalSerializer.cs | 628 +++--- .../HyperLinkSerializer.cs | 442 +++-- .../IdCorrespondenceSerializer.cs | 415 ++-- ...endentParameterTypeAssignmentSerializer.cs | 351 ++-- .../IntervalScaleSerializer.cs | 1199 ++++++------ .../IterationSerializer.cs | 1710 +++++++++-------- .../IterationSetupSerializer.cs | 762 ++++---- .../LinearConversionUnitSerializer.cs | 837 ++++---- .../LogEntryChangelogItemSerializer.cs | 375 ++-- .../LogarithmicScaleSerializer.cs | 1464 +++++++------- .../MappingToReferenceScaleSerializer.cs | 415 ++-- .../ModelLogEntrySerializer.cs | 896 +++++---- .../ModelReferenceDataLibrarySerializer.cs | 1367 +++++++------ .../ModellingThingReferenceSerializer.cs | 384 ++-- .../MultiRelationshipRuleSerializer.cs | 975 +++++----- .../MultiRelationshipSerializer.cs | 624 +++--- .../NaturalLanguageSerializer.cs | 442 +++-- .../NestedElementSerializer.cs | 573 +++--- .../NestedParameterSerializer.cs | 595 +++--- .../NotExpressionSerializer.cs | 388 ++-- .../AutoGenDtoSerializer/OptionSerializer.cs | 866 +++++---- .../OrExpressionSerializer.cs | 440 +++-- .../OrdinalScaleSerializer.cs | 1236 ++++++------ .../OrganizationSerializer.cs | 442 +++-- .../OrganizationalParticipantSerializer.cs | 298 +-- .../OwnedStyleSerializer.cs | 1061 +++++----- .../AutoGenDtoSerializer/PageSerializer.cs | 550 +++--- .../ParameterGroupSerializer.cs | 487 ++--- .../ParameterOverrideSerializer.cs | 573 +++--- .../ParameterOverrideValueSetSerializer.cs | 510 ++--- .../ParameterSerializer.cs | 1030 +++++----- .../ParameterSubscriptionSerializer.cs | 467 +++-- ...ParameterSubscriptionValueSetSerializer.cs | 434 +++-- .../ParameterTypeComponentSerializer.cs | 514 ++--- .../ParameterValueSetSerializer.cs | 671 ++++--- .../ParameterizedCategoryRuleSerializer.cs | 869 +++++---- .../ParametricConstraintSerializer.cs | 505 ++--- .../ParticipantPermissionSerializer.cs | 442 +++-- .../ParticipantRoleSerializer.cs | 838 ++++---- .../ParticipantSerializer.cs | 548 +++--- .../PersonPermissionSerializer.cs | 442 +++-- .../PersonRoleSerializer.cs | 838 ++++---- .../AutoGenDtoSerializer/PersonSerializer.cs | 1154 ++++++----- .../AutoGenDtoSerializer/PointSerializer.cs | 406 ++-- .../PossibleFiniteStateListSerializer.cs | 962 +++++----- .../PossibleFiniteStateSerializer.cs | 648 ++++--- .../PrefixedUnitSerializer.cs | 741 +++---- .../PublicationSerializer.cs | 546 +++--- .../QuantityKindFactorSerializer.cs | 415 ++-- .../RatioScaleSerializer.cs | 1199 ++++++------ .../ReferenceSourceSerializer.cs | 1163 ++++++----- .../ReferencerRuleSerializer.cs | 975 +++++----- .../RelationalExpressionSerializer.cs | 533 ++--- .../RelationshipParameterValueSerializer.cs | 454 +++-- .../RequestForDeviationSerializer.cs | 1039 +++++----- .../RequestForWaiverSerializer.cs | 1039 +++++----- .../RequirementSerializer.cs | 1076 ++++++----- ...ementsContainerParameterValueSerializer.cs | 454 +++-- .../RequirementsGroupSerializer.cs | 996 +++++----- .../RequirementsSpecificationSerializer.cs | 1068 +++++----- .../ReviewItemDiscrepancySerializer.cs | 1122 ++++++----- .../RuleVerificationListSerializer.cs | 838 ++++---- .../RuleViolationSerializer.cs | 467 +++-- .../SampledFunctionParameterTypeSerializer.cs | 673 ++++--- .../ScaleReferenceQuantityValueSerializer.cs | 415 ++-- .../ScaleValueDefinitionSerializer.cs | 741 +++---- .../AutoGenDtoSerializer/SectionSerializer.cs | 550 +++--- .../SharedStyleSerializer.cs | 1061 +++++----- .../SimpleParameterValueSerializer.cs | 506 ++--- .../SimpleQuantityKindSerializer.cs | 1032 +++++----- .../SimpleUnitSerializer.cs | 741 +++---- .../SiteDirectoryDataAnnotationSerializer.cs | 572 +++--- ...teDirectoryDataDiscussionItemSerializer.cs | 504 ++--- .../SiteDirectorySerializer.cs | 1418 +++++++------- .../SiteDirectoryThingReferenceSerializer.cs | 384 ++-- .../SiteLogEntrySerializer.cs | 896 +++++---- .../SiteReferenceDataLibrarySerializer.cs | 1544 ++++++++------- .../SolutionSerializer.cs | 450 +++-- .../SpecializedQuantityKindSerializer.cs | 1069 ++++++----- .../StakeHolderValueMapSerializer.cs | 1015 +++++----- .../StakeHolderValueMapSettingsSerializer.cs | 538 +++--- .../StakeholderSerializer.cs | 783 ++++---- .../StakeholderValueSerializer.cs | 628 +++--- .../TelephoneNumberSerializer.cs | 467 +++-- .../AutoGenDtoSerializer/TermSerializer.cs | 741 +++---- .../TextParameterTypeSerializer.cs | 895 +++++---- .../TextualNoteSerializer.cs | 533 ++--- .../TimeOfDayParameterTypeSerializer.cs | 895 +++++---- .../UnitFactorSerializer.cs | 415 ++-- .../UnitPrefixSerializer.cs | 808 ++++---- .../UserPreferenceSerializer.cs | 415 ++-- .../UserRuleVerificationSerializer.cs | 620 +++--- .../ValueGroupSerializer.cs | 628 +++--- .../ActualFiniteStateKindDeserializer.cs | 64 + .../AnnotationApprovalKindDeserializer.cs | 65 + ...nnotationClassificationKindDeserializer.cs | 64 + .../AnnotationStatusKindDeserializer.cs | 68 + .../BooleanOperatorKindDeserializer.cs | 65 + .../ClassKindDeserializer.cs | 243 +++ .../EngineeringModelKindDeserializer.cs | 66 + .../InterfaceEndKindDeserializer.cs | 67 + .../LogEntryChangelogItemKindDeserializer.cs | 65 + .../LogLevelKindDeserializer.cs | 66 + .../LogarithmBaseKindDeserializer.cs | 65 + .../NumberSetKindDeserializer.cs | 66 + .../ParameterSwitchKindDeserializer.cs | 65 + .../ParticipantAccessRightKindDeserializer.cs | 69 + .../PersonAccessRightKindDeserializer.cs | 71 + .../RelationalOperatorKindDeserializer.cs | 68 + .../RuleVerificationStatusKindDeserializer.cs | 66 + .../StudyPhaseKindDeserializer.cs | 66 + .../VcardEmailAddressKindDeserializer.cs | 64 + .../VcardTelephoneNumberKindDeserializer.cs | 71 + CDP4JsonSerializer/CDP4JsonSerializer.csproj | 26 +- CDP4JsonSerializer/Cdp4JsonSerializer.cs | 180 +- .../DtoSerializer/BaseThingSerializer.cs | 40 +- .../DtoSerializer/IThingSerializer.cs | 53 +- CDP4JsonSerializer/Helper/SerializerHelper.cs | 132 +- CDP4JsonSerializer/ICdp4JsonSerializer.cs | 47 +- .../JsonConverter/ClassKindConverter.cs | 50 - .../JsonConverter/ClasslessDtoSerializer.cs | 172 +- .../JsonConverter/ThingConverterExtensions.cs | 111 ++ .../JsonConverter/ThingSerializer.cs | 159 +- CDP4JsonSerializer/Properties/AssemblyInfo.cs | 5 +- CDP4JsonSerializer/SerializerOptions.cs | 88 + .../CDP4ServicesDal.NetCore.Tests.csproj | 3 +- .../CdpServicesDalTestFixture.cs | 54 +- .../CopyOperationHandlerTestFixture.cs | 14 +- .../OperationModifierTestFixture.cs | 14 +- .../PostOperationTestFixture.cs | 49 +- .../CdpServicesDalTestFixture.cs | 57 +- .../CopyOperationHandlerTestFixture.cs | 14 +- .../OperationModifierTestFixture.cs | 14 +- .../PostOperationTestFixture.cs | 52 +- CDP4ServicesDal/CDP4ServicesDal.csproj | 7 +- CDP4ServicesDal/CdpPostOperation.cs | 49 +- CDP4ServicesDal/CdpServicesDal.cs | 48 +- CDP4ServicesDal/CopyOperationHandler.cs | 43 +- CDP4ServicesDal/OperationModifier.cs | 51 +- CDP4ServicesDal/ValueSetOperationCreator.cs | 45 +- .../CDP4ServicesMessaging.csproj | 2 +- .../Serializers/Json/Cdp4MessageSerializer.cs | 40 +- .../CopyOperationHandlerTestFixture.cs | 14 +- .../OperationModifierTestFixture.cs | 14 +- .../Operations/WSPPostOperationTestFixture.cs | 38 +- .../PostOperationTestFixture.cs | 69 +- CDP4WspDal.NetCore.Tests/WSPDalTestFixture.cs | 14 +- .../CopyOperationHandlerTestFixture.cs | 14 +- .../OperationModifierTestFixture.cs | 14 +- .../Operations/WSPPostOperationTestFixture.cs | 38 +- CDP4WspDal.Tests/PostOperationTestFixture.cs | 68 +- CDP4WspDal.Tests/WSPDalTestFixture.cs | 14 +- CDP4WspDal/CDP4WspDal.csproj | 2 +- CDP4WspDal/CopyOperationHandler.cs | 53 +- CDP4WspDal/OperationModifier.cs | 55 +- CDP4WspDal/ValueSetOperationCreator.cs | 51 +- CDP4WspDal/WSPDal.cs | 64 +- CDP4WspDal/WSPPostOperation.cs | 47 +- 400 files changed, 64329 insertions(+), 51870 deletions(-) rename {CDP4Dal => CDP4DalCommon/Protocol}/Operations/Operation.cs (75%) rename {CDP4Dal => CDP4DalCommon/Protocol}/Operations/OperationKind.cs (80%) rename {CDP4Dal => CDP4DalCommon/Protocol}/Operations/PostOperation.cs (76%) rename CDP4DalCommon/{ => Protocol}/Tasks/CometTask.cs (92%) rename CDP4DalCommon/{ => Protocol}/Tasks/StatusKind.cs (52%) create mode 100644 CDP4DalJsonSerializer/CDP4DalJsonSerializer.csproj create mode 100644 CDP4DalJsonSerializer/Cdp4DalJsonSerializer.cs create mode 100644 CDP4DalJsonSerializer/Extensions/JsonElementExtensions.cs create mode 100644 CDP4DalJsonSerializer/JsonConverter/PostOperationJsonConverter.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/ActualFiniteStateKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationApprovalKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationClassificationKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationStatusKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/BooleanOperatorKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/ClassKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/EngineeringModelKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/InterfaceEndKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/LogEntryChangelogItemKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/LogLevelKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/LogarithmBaseKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/NumberSetKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/ParameterSwitchKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/ParticipantAccessRightKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/PersonAccessRightKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/RelationalOperatorKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/RuleVerificationStatusKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/StudyPhaseKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/VcardEmailAddressKindDeserializer.cs create mode 100644 CDP4JsonSerializer/AutoGenEnumDeserializers/VcardTelephoneNumberKindDeserializer.cs delete mode 100644 CDP4JsonSerializer/JsonConverter/ClassKindConverter.cs create mode 100644 CDP4JsonSerializer/JsonConverter/ThingConverterExtensions.cs create mode 100644 CDP4JsonSerializer/SerializerOptions.cs diff --git a/CDP4-SDK.sln b/CDP4-SDK.sln index 801dc90c..6a69cabc 100644 --- a/CDP4-SDK.sln +++ b/CDP4-SDK.sln @@ -78,6 +78,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CDP4ServicesMessaging.Tests EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CDP4DalCommon", "CDP4DalCommon\CDP4DalCommon.csproj", "{E7CDB217-8442-4FD4-8E87-F4A8BFE9622A}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CDP4DalJsonSerializer", "CDP4DalJsonSerializer\CDP4DalJsonSerializer.csproj", "{36C38A02-C1CF-4F4F-AB40-F0A231256B30}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -208,6 +210,10 @@ Global {E7CDB217-8442-4FD4-8E87-F4A8BFE9622A}.Debug|Any CPU.Build.0 = Debug|Any CPU {E7CDB217-8442-4FD4-8E87-F4A8BFE9622A}.Release|Any CPU.ActiveCfg = Release|Any CPU {E7CDB217-8442-4FD4-8E87-F4A8BFE9622A}.Release|Any CPU.Build.0 = Release|Any CPU + {36C38A02-C1CF-4F4F-AB40-F0A231256B30}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {36C38A02-C1CF-4F4F-AB40-F0A231256B30}.Debug|Any CPU.Build.0 = Debug|Any CPU + {36C38A02-C1CF-4F4F-AB40-F0A231256B30}.Release|Any CPU.ActiveCfg = Release|Any CPU + {36C38A02-C1CF-4F4F-AB40-F0A231256B30}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/CDP4-SDK.sln.DotSettings b/CDP4-SDK.sln.DotSettings index 3e8a67ef..64ed4378 100644 --- a/CDP4-SDK.sln.DotSettings +++ b/CDP4-SDK.sln.DotSettings @@ -246,7 +246,7 @@ <copyright file="${File.FileName}" company="Starion Group S.A."> Copyright (c) 2015-${CurrentDate.Year} Starion Group S.A. - Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar + Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar This file is part of CDP4-COMET SDK Community Edition diff --git a/CDP4Dal.NetCore.Tests/DAL/DalTestFixture.cs b/CDP4Dal.NetCore.Tests/DAL/DalTestFixture.cs index b59f1a5c..f199eb51 100644 --- a/CDP4Dal.NetCore.Tests/DAL/DalTestFixture.cs +++ b/CDP4Dal.NetCore.Tests/DAL/DalTestFixture.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Tests.DAL { @@ -36,11 +36,12 @@ namespace CDP4Dal.Tests.DAL using CDP4Common.Helpers; using CDP4Dal.Composition; + using CDP4Dal.DAL; using CDP4Dal.Exceptions; using CDP4Dal.Operations; - using CDP4Dal.DAL; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Operations; + using CDP4DalCommon.Protocol.Tasks; using NUnit.Framework; @@ -140,6 +141,7 @@ public void Verify_That_SetIterationId_Works_as_expected() var iteration = new Iteration(); var elementDefinition = new ElementDefinition(); var parameter = new Parameter(); + var list = new List { model, @@ -303,7 +305,10 @@ public void Verify_that_OperationContainerFileVerification_throws_no_exception_w [CDPVersion("1.1.0")] internal class TestDal : Dal { - public override bool IsReadOnly { get { return false; } } + public override bool IsReadOnly + { + get { return false; } + } public TestDal(Credentials credentials) : base() @@ -451,6 +456,7 @@ public override Task> CherryPick(Guid engineeringModelId, Gui internal class DecoratedDal : Dal { public override bool IsReadOnly { get; } + public override Task> Write(IEnumerable operationContainer, IEnumerable files = null) { throw new NotImplementedException(); @@ -566,4 +572,4 @@ public override Task> CherryPick(Guid engineeringModelId, Gui throw new NotSupportedException(); } } -} \ No newline at end of file +} diff --git a/CDP4Dal.NetCore.Tests/Operations/OperationContainerTestFixture.cs b/CDP4Dal.NetCore.Tests/Operations/OperationContainerTestFixture.cs index a24abc35..27722f0e 100644 --- a/CDP4Dal.NetCore.Tests/Operations/OperationContainerTestFixture.cs +++ b/CDP4Dal.NetCore.Tests/Operations/OperationContainerTestFixture.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Tests { @@ -28,10 +28,14 @@ namespace CDP4Dal.Tests using System.Linq; using CDP4Common.CommonData; - using CDP4Common.DTO; + using CDP4Common.DTO; + using CDP4Dal.Operations; + + using CDP4DalCommon.Protocol.Operations; + using NUnit.Framework; - + [TestFixture] public class OperationContainerTestFixture { @@ -42,7 +46,7 @@ public class OperationContainerTestFixture [SetUp] public void SetUp() { - this.siteDirectoryContext = "/SiteDirectory/47363f0d-eb6d-4a58-95f5-fa7854995650"; + this.siteDirectoryContext = "/SiteDirectory/47363f0d-eb6d-4a58-95f5-fa7854995650"; this.iterationContext = "/EngineeringModel/5e5dc7f8-833d-4331-b421-eb2c64fcf64b/iteration/b58ea73d-350d-4520-b9d9-a52c75ac2b5d"; } @@ -98,9 +102,9 @@ public void VerifyExecutionOfOperationAddAndRemove() var elementDefinition = new ElementDefinition(Guid.NewGuid(), 0); elementDefinition.PartialRoutes.Add("iteration/b58ea73d-350d-4520-b9d9-a52c75ac2b5d"); elementDefinition.PartialRoutes.Add("EngineeringModel/5e5dc7f8-833d-4331-b421-eb2c64fcf64b"); - + var clone = elementDefinition.DeepClone(); - var operation = new Operation(elementDefinition, clone, OperationKind.Update); + var operation = new Operation(elementDefinition, clone, OperationKind.Update); var operationContainer = new OperationContainer(this.iterationContext); diff --git a/CDP4Dal.NetCore.Tests/Operations/OperationTestFixture.cs b/CDP4Dal.NetCore.Tests/Operations/OperationTestFixture.cs index f0e46dd6..fb6565ed 100644 --- a/CDP4Dal.NetCore.Tests/Operations/OperationTestFixture.cs +++ b/CDP4Dal.NetCore.Tests/Operations/OperationTestFixture.cs @@ -1,32 +1,32 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Tests { using CDP4Common.DTO; - using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; using NUnit.Framework; diff --git a/CDP4Dal.NetCore.Tests/Operations/PostOperationTestFixture.cs b/CDP4Dal.NetCore.Tests/Operations/PostOperationTestFixture.cs index 29bda68f..7ab265d9 100644 --- a/CDP4Dal.NetCore.Tests/Operations/PostOperationTestFixture.cs +++ b/CDP4Dal.NetCore.Tests/Operations/PostOperationTestFixture.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Tests { @@ -29,9 +29,9 @@ namespace CDP4Dal.Tests using CDP4Common; using CDP4Common.Dto; using CDP4Common.DTO; - - using CDP4Dal.Operations; - + + using CDP4DalCommon.Protocol.Operations; + using NUnit.Framework; [TestFixture] @@ -51,9 +51,13 @@ public void VerifyThatConstructorSetsLists() internal class TestPostOperation : PostOperation { public override List Delete { get; set; } + public override List Create { get; set; } + public override List Update { get; set; } + public override List Copy { get; set; } + public override void ConstructFromOperation(Operation operation) { throw new System.NotImplementedException(); diff --git a/CDP4Dal.NetCore.Tests/Operations/ThingTransactionTestFixture.cs b/CDP4Dal.NetCore.Tests/Operations/ThingTransactionTestFixture.cs index 848587a4..8a7fc1d5 100644 --- a/CDP4Dal.NetCore.Tests/Operations/ThingTransactionTestFixture.cs +++ b/CDP4Dal.NetCore.Tests/Operations/ThingTransactionTestFixture.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Tests { @@ -34,9 +34,11 @@ namespace CDP4Dal.Tests using CDP4Common.EngineeringModelData; using CDP4Common.SiteDirectoryData; using CDP4Common.Types; - + using CDP4Dal.Operations; - + + using CDP4DalCommon.Protocol.Operations; + using NUnit.Framework; /// @@ -131,6 +133,7 @@ public void VerifyThatCreateThingWorksWithAbstractContainer() { Container = this.siteDirectory }; + this.cache.TryAdd(new CacheKey(siteRdl.Iid, null), new Lazy(() => siteRdl)); var cloneRdl = siteRdl.Clone(false); @@ -183,7 +186,7 @@ public void VerifyThatCreateThingTwiceDoesntThrowException() var transaction = new ThingTransaction(transactionContext, this.siteDirectory.Clone(false)); var phone = new TelephoneNumber(Guid.NewGuid(), this.cache, this.uri); - Assert.That(() => + Assert.That(() => { transaction.Create(phone); transaction.Create(phone); @@ -246,7 +249,6 @@ public void VerifyThatDeleteThingAlreadyDeletedWorks() [Test] public void VerifyThatUpdateContainerWorks() { - var iterationClone = this.iteration.Clone(false); var option1 = new Option(Guid.NewGuid(), this.cache, this.uri); @@ -328,6 +330,7 @@ public void FunctionalTestCase1() emailTrans.Create(email); emailTrans.FinalizeSubTransaction(email, person1_1); + // end add email, verify that email is added to person1_1, (the clone of person1) Assert.That(2, Is.EqualTo(person1_1Tr.AddedThing.Count())); @@ -339,6 +342,7 @@ public void FunctionalTestCase1() var phone_1Trans = new ThingTransaction(phone_1, person1_1Tr, person1_1); phone_1Trans.CreateOrUpdate(phone_1); phone_1Trans.FinalizeSubTransaction(phone_1, person1_1); + // end update phone // verify that the new reference is used @@ -354,7 +358,6 @@ public void FunctionalTestCase1() Assert.That(rootTransaction.AddedThing.Contains(phone_1), Is.True); Assert.That(1, Is.EqualTo(cloneSiteDir.Person.Count)); - // Create new person var person2 = new Person(); var person2Trans = new ThingTransaction(person2, rootTransaction, cloneSiteDir); @@ -828,6 +831,7 @@ public void VerifyThatCascadeDeleteWorksOnAddedThing() transaction.Delete(person.Clone(false)); var operationContainer = transaction.FinalizeTransaction(); + // Update sitedir Assert.That(1, Is.EqualTo(operationContainer.Operations.Count())); } diff --git a/CDP4Dal.NetCore.Tests/SessionTestFixture.cs b/CDP4Dal.NetCore.Tests/SessionTestFixture.cs index b978e39e..33430a26 100644 --- a/CDP4Dal.NetCore.Tests/SessionTestFixture.cs +++ b/CDP4Dal.NetCore.Tests/SessionTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.NetCore.Tests { @@ -37,17 +37,18 @@ namespace CDP4Dal.NetCore.Tests using CDP4Common.Types; using CDP4Dal.Composition; - using CDP4Dal.Operations; using CDP4Dal.DAL; using CDP4Dal.Events; using CDP4Dal.Exceptions; + using CDP4Dal.Operations; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Operations; + using CDP4DalCommon.Protocol.Tasks; using Moq; - + using NUnit.Framework; - + using DomainOfExpertise = CDP4Common.SiteDirectoryData.DomainOfExpertise; using EngineeringModelSetup = CDP4Common.DTO.EngineeringModelSetup; using ModelReferenceDataLibrary = CDP4Common.SiteDirectoryData.ModelReferenceDataLibrary; @@ -129,10 +130,7 @@ public void TearDown() public async Task VerifythatOpenCallAssemblerSynchronizeWithDtos() { var eventReceived = false; - this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => - { - eventReceived = true; - }); + this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => { eventReceived = true; }); await this.session.Open(); @@ -149,20 +147,20 @@ public async Task VerifyThatWriteWithEmptyResponseSendsMessages() writeWithNoResultsTaskCompletionSource.SetResult(new List()); this.mockedDal.Setup(x => x.Open(It.IsAny(), It.IsAny())).Returns(writeWithNoResultsTaskCompletionSource.Task); - this.messageBus.Listen() - .Subscribe(x => - { - if (x.Status == SessionStatus.BeginUpdate) + this.messageBus.Listen() + .Subscribe(x => { - beginUpdateReceived = true; - return; - } + if (x.Status == SessionStatus.BeginUpdate) + { + beginUpdateReceived = true; + return; + } - if (x.Status == SessionStatus.EndUpdate) - { - endUpdateReceived = true; - } - }); + if (x.Status == SessionStatus.EndUpdate) + { + endUpdateReceived = true; + } + }); var context = $"/SiteDirectory/{Guid.NewGuid()}"; @@ -186,13 +184,10 @@ public async Task VerifythatRefreshSynchronizeTheAssembler() var readTaskCompletionSource = new TaskCompletionSource>(); readTaskCompletionSource.SetResult(this.dalOutputs); this.mockedDal.Setup(x => x.Read(It.IsAny(), It.IsAny(), It.Is(query => query.RevisionNumber == 0))).Returns(readTaskCompletionSource.Task); - + await this.session.Open(); - this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => - { - eventReceived = true; - }); + this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => { eventReceived = true; }); // refresh shouldnt do anything await this.session.Refresh(); @@ -216,10 +211,7 @@ public async Task VerifythatReloadSynchronizeTheAssembler() await this.session.Open(); - this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => - { - eventReceived = true; - }); + this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => { eventReceived = true; }); await this.session.Reload(); @@ -277,10 +269,10 @@ public async Task VerifyThatCloseRdlWorks() var rdlDto = new CDP4Common.DTO.SiteReferenceDataLibrary { Iid = Guid.NewGuid() }; var rdlPoco = new CDP4Common.SiteDirectoryData.SiteReferenceDataLibrary { Iid = rdlDto.Iid, Name = rdlDto.Name, ShortName = rdlDto.ShortName, Container = siteDirectoryPoco }; - + var requiredSiteReferenceDataLibraryDto = new CDP4Common.DTO.SiteReferenceDataLibrary() { Iid = Guid.NewGuid() }; var requiredSiteReferenceDataLibraryPoco = new CDP4Common.SiteDirectoryData.SiteReferenceDataLibrary(requiredSiteReferenceDataLibraryDto.Iid, this.session.Assembler.Cache, this.uri); - + rdlDto.RequiredRdl = requiredSiteReferenceDataLibraryDto.Iid; rdlPoco.RequiredRdl = requiredSiteReferenceDataLibraryPoco; @@ -319,7 +311,7 @@ public async Task VerifyThatSiteRdlRequiredByModelRdlCannotBeClosed() rdlDto.RequiredRdl = requiredRdlDto.Iid; siteDirDto.SiteReferenceDataLibrary.Add(rdlDto.Iid); siteDirDto.SiteReferenceDataLibrary.Add(requiredRdlDto.Iid); - + siteDirDto.Person.Add(this.person.Iid); var mrdl = new CDP4Common.DTO.ModelReferenceDataLibrary(Guid.NewGuid(), 0) { RequiredRdl = requiredRdlDto.Iid }; @@ -348,14 +340,15 @@ public async Task VerifyThatSiteRdlRequiredByModelRdlCannotBeClosed() var participant = new CDP4Common.DTO.Participant(Guid.NewGuid(), 0) { Person = this.person.Iid }; modelsetup.Participant.Add(participant.Iid); - var modelPoco = new CDP4Common.EngineeringModelData.EngineeringModel(model.Iid, null, null){EngineeringModelSetup = modelsetuppoco}; + var modelPoco = new CDP4Common.EngineeringModelData.EngineeringModel(model.Iid, null, null) { EngineeringModelSetup = modelsetuppoco }; var iterationPoco = new CDP4Common.EngineeringModelData.Iteration(iteration.Iid, null, null); modelPoco.Iteration.Add(iterationPoco); var readTaskCompletionSource = new TaskCompletionSource>(); readTaskCompletionSource.SetResult(readReturn); + this.mockedDal.Setup( - x => x.Read(It.IsAny(), It.IsAny(), null)) + x => x.Read(It.IsAny(), It.IsAny(), null)) .Returns(readTaskCompletionSource.Task); var thingsToAdd = new List() { siteDirDto, requiredRdlDto, rdlDto, this.person, participant, modelsetup }; @@ -389,8 +382,8 @@ public async Task VerifyThatCloseModelRdlWorks() siteDir.Model.Add(containerEngModelSetup); modelRdlDto.RequiredRdl = requiredPocoDto.Iid; siteDir.Person.Add(JohnDoe); - - var credentials = new Credentials("admin", "pass", new Uri("http://www.stariongroup.eu")); + + var credentials = new Credentials("admin", "pass", new Uri("http://www.rheagroup.com")); var session2 = new Session(this.mockedDal.Object, credentials, this.messageBus); session2.GetType().GetProperty("ActivePerson").SetValue(session2, JohnDoe, null); @@ -449,6 +442,7 @@ public async Task VerifyThatReadRdlWorks() { var siteDir = new CDP4Common.SiteDirectoryData.SiteDirectory(Guid.NewGuid(), this.session.Assembler.Cache, this.uri); var JohnDoe = new CDP4Common.SiteDirectoryData.Person(this.person.Iid, this.session.Assembler.Cache, this.uri) { ShortName = "John" }; + this.session.Assembler.Cache.TryAdd(new CacheKey(siteDir.Iid, null), new Lazy(() => siteDir)); @@ -518,14 +512,14 @@ public async Task Verify_that_EngineeringModel_returns_result() await this.session.Read(iids); - Assert.That(this.session.Assembler.Cache.ContainsKey(new CacheKey(engineeringModel.Iid, null)), Is.True); + Assert.That(this.session.Assembler.Cache.ContainsKey(new CacheKey(engineeringModel.Iid, null)), Is.True); } [Test] public async Task VerifyThatReadIterationWorks() { var siteDir = new CDP4Common.SiteDirectoryData.SiteDirectory(Guid.NewGuid(), this.session.Assembler.Cache, this.uri); - var JohnDoe = new CDP4Common.SiteDirectoryData.Person(this.person.Iid, this.session.Assembler.Cache, this.uri) {ShortName = "John"}; + var JohnDoe = new CDP4Common.SiteDirectoryData.Person(this.person.Iid, this.session.Assembler.Cache, this.uri) { ShortName = "John" }; var modelSetup = new CDP4Common.SiteDirectoryData.EngineeringModelSetup(Guid.NewGuid(), this.session.Assembler.Cache, this.uri); var iterationSetup = new CDP4Common.SiteDirectoryData.IterationSetup(Guid.NewGuid(), this.session.Assembler.Cache, this.uri) { FrozenOn = DateTime.Now, IterationIid = Guid.NewGuid() }; var mrdl = new ModelReferenceDataLibrary(Guid.NewGuid(), this.session.Assembler.Cache, this.uri); @@ -570,7 +564,7 @@ public async Task VerifyThatReadIterationWorks() var iterationToOpen = new CDP4Common.EngineeringModelData.Iteration(iteration.Iid, null, null); var modelToOpen = new CDP4Common.EngineeringModelData.EngineeringModel(model.Iid, null, null); iterationToOpen.Container = modelToOpen; - + await this.session.Read(iterationToOpen, activeDomain); this.mockedDal.Verify(x => x.Read(It.Is(i => i.Iid == iterationToOpen.Iid), It.IsAny(), It.IsAny()), Times.Once); @@ -607,7 +601,7 @@ public void Verify_that_when_active_person_is_null_Iteration_is_not_read() var activeDomain = new DomainOfExpertise(Guid.NewGuid(), null, null); var model = new EngineeringModel(Guid.NewGuid(), 1); var iteration = new Iteration(Guid.NewGuid(), 10) { IterationSetup = iterationSetup.Iid }; - + var iterationToOpen = new CDP4Common.EngineeringModelData.Iteration(iteration.Iid, null, null); var modelToOpen = new CDP4Common.EngineeringModelData.EngineeringModel(model.Iid, null, null); iterationToOpen.Container = modelToOpen; @@ -664,10 +658,7 @@ public async Task VerifyThatWriteWorksWithEventHandler() var johnDoe = new CDP4Common.SiteDirectoryData.Person(this.person.Iid, this.session.Assembler.Cache, this.uri) { ShortName = "John" }; this.session.GetType().GetProperty("ActivePerson")?.SetValue(this.session, johnDoe, null); - this.session.BeforeWrite += (o, args) => - { - args.Cancelled = false; - }; + this.session.BeforeWrite += (o, args) => { args.Cancelled = false; }; await this.session.Write(new OperationContainer(context)); @@ -681,10 +672,7 @@ public void VerifyThatCancelWriteWorks() var johnDoe = new CDP4Common.SiteDirectoryData.Person(this.person.Iid, this.session.Assembler.Cache, this.uri) { ShortName = "John" }; this.session.GetType().GetProperty("ActivePerson")?.SetValue(this.session, johnDoe, null); - this.session.BeforeWrite += (o, args) => - { - args.Cancelled = true; - }; + this.session.BeforeWrite += (o, args) => { args.Cancelled = true; }; Assert.ThrowsAsync(async () => await this.session.Write(new OperationContainer(context))); @@ -746,11 +734,11 @@ public async Task VerifyCanReadCometTasks() var returnedCometTasks = new List() { - new () + new() { Id = Guid.NewGuid() }, - new () + new() { Id = Guid.NewGuid() }, @@ -788,7 +776,7 @@ public async Task VerifyWritePossibleLongRunningTask() this.mockedDal.Setup(x => x.Write(It.IsAny(), It.IsAny(), It.IsAny>())) .ReturnsAsync(new LongRunningTaskResult(new CometTask() { Id = Guid.Empty })); - + var cometTask = await this.session.Write(new OperationContainer(context), 1); Assert.Multiple(() => @@ -817,7 +805,7 @@ public async Task VerifyWritePossibleLongRunningTask() this.mockedDal.Setup(x => x.Write(It.IsAny(), It.IsAny(), It.IsAny>())) .ThrowsAsync(new DalReadException()); - Assert.That(() =>this.session.Write(new OperationContainer(context), 1), Throws.Exception.TypeOf()); + Assert.That(() => this.session.Write(new OperationContainer(context), 1), Throws.Exception.TypeOf()); } private void AssignActivePerson() @@ -830,17 +818,30 @@ private void AssignActivePerson() [DalExport("test dal", "test dal description", "1.1.0", DalType.Web)] internal class TestDal : IDal { - public Version SupportedVersion { get {return new Version(1, 0, 0);} } + public Version SupportedVersion + { + get { return new Version(1, 0, 0); } + } - public Version DalVersion { get {return new Version("1.1.0");} } - public IMetaDataProvider MetaDataProvider { get {return new MetaDataProvider();} } + public Version DalVersion + { + get { return new Version("1.1.0"); } + } + + public IMetaDataProvider MetaDataProvider + { + get { return new MetaDataProvider(); } + } /// /// Gets or sets the that uses this /// public ISession Session { get; set; } - public bool IsReadOnly { get { return false; } } + public bool IsReadOnly + { + get { return false; } + } /// /// Write all the s from all the s asynchronously. @@ -958,7 +959,7 @@ public Task> Read(Iteration iteration, CancellationToken canc /// A list of s /// /// - /// Only those s are retunred that the is a in + /// Only those s are retunred that the is a in /// public Task> Read(IEnumerable engineeringModels, CancellationToken cancellationToken) { @@ -1097,4 +1098,4 @@ public Task> CherryPick(Guid engineeringModelId, Guid iterati throw new System.NotImplementedException(); } } -} \ No newline at end of file +} diff --git a/CDP4Dal.Tests/DAL/DalTestFixture.cs b/CDP4Dal.Tests/DAL/DalTestFixture.cs index 536f3b88..ce72d638 100644 --- a/CDP4Dal.Tests/DAL/DalTestFixture.cs +++ b/CDP4Dal.Tests/DAL/DalTestFixture.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2020 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Tests.DAL { @@ -36,11 +36,11 @@ namespace CDP4Dal.Tests.DAL using CDP4Common.Helpers; using CDP4Dal.Composition; + using CDP4Dal.DAL; using CDP4Dal.Exceptions; using CDP4Dal.Operations; - using CDP4Dal.DAL; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Tasks; using NUnit.Framework; @@ -64,7 +64,7 @@ public void SetUp() [Test] public void Verify_that_the_credentials_are_set_to_Null_when_closed() { - var dal = new TestDal(this.credentials); + var dal = new TestDal(this.credentials); dal.CloseSession(); Assert.That(dal.Credentials, Is.Null); } @@ -140,6 +140,7 @@ public void Verify_That_SetIterationId_Works_as_expected() var iteration = new Iteration(); var elementDefinition = new ElementDefinition(); var parameter = new Parameter(); + var list = new List { model, @@ -206,8 +207,8 @@ public void Verify_that_when_SetIterationContainer_is_called_with_empty_guid_exc public void Verify_That_QueryRequestContext_Returns_Expected_Result() { var testdal = new TestDal(this.credentials); - - var elementDefinitionUri = new Uri("http://www.stariongroup.eu/EngineeringModel/00B1FD7E-BE0F-4512-A406-02FCBD63E06A/iteration/0111A76D-346D-4055-A78D-B8215B993DA1/element/E9E8E386-B8BB-44F1-80B9-2C30761EE688"); + + var elementDefinitionUri = new Uri("http://www.rheagroup.com/EngineeringModel/00B1FD7E-BE0F-4512-A406-02FCBD63E06A/iteration/0111A76D-346D-4055-A78D-B8215B993DA1/element/E9E8E386-B8BB-44F1-80B9-2C30761EE688"); var elementDefinitionContext = testdal.QueryRequestContext(elementDefinitionUri); Assert.That("/EngineeringModel/00B1FD7E-BE0F-4512-A406-02FCBD63E06A/iteration/0111A76D-346D-4055-A78D-B8215B993DA1", Is.EqualTo(elementDefinitionContext)); } @@ -216,7 +217,7 @@ public void Verify_That_QueryRequestContext_Returns_Expected_Result() public void Verify_that_for_a_decorated_dal_the_version_is_set() { var dal = new DecoratedDal(); - Assert.That(dal.DalVersion, Is.EqualTo(new Version(1,1,0))); + Assert.That(dal.DalVersion, Is.EqualTo(new Version(1, 1, 0))); } [Test] @@ -238,7 +239,7 @@ public void Verify_that_OperationContainerFileVerification_throws_an_exception_w var commonFileStore = new CDP4Common.EngineeringModelData.CommonFileStore(Guid.NewGuid(), null, null); engineeringModel.Iteration.Add(iteration); engineeringModel.CommonFileStore.Add(commonFileStore); - + var context = TransactionContextResolver.ResolveContext(commonFileStore); var transaction = new ThingTransaction(context); @@ -246,13 +247,13 @@ public void Verify_that_OperationContainerFileVerification_throws_an_exception_w var file = new CDP4Common.EngineeringModelData.File(Guid.NewGuid(), null, null); var fileRevision = new CDP4Common.EngineeringModelData.FileRevision(Guid.NewGuid(), null, null); - + transaction.Create(file, commonFileStoreClone); transaction.Create(fileRevision, file); var operationContainer = transaction.FinalizeTransaction(); - var files = new List {this.filePath}; + var files = new List { this.filePath }; var testDal = new TestDal(this.credentials); Assert.Throws(() => testDal.TestOperationContainerFileVerification(operationContainer, files)); @@ -277,7 +278,7 @@ public void Verify_that_OperationContainerFileVerification_throws_no_exception_w var commonFileStore = new CDP4Common.EngineeringModelData.CommonFileStore(Guid.NewGuid(), null, null); engineeringModel.Iteration.Add(iteration); engineeringModel.CommonFileStore.Add(commonFileStore); - + var context = TransactionContextResolver.ResolveContext(commonFileStore); var transaction = new ThingTransaction(context); @@ -286,13 +287,13 @@ public void Verify_that_OperationContainerFileVerification_throws_no_exception_w var file = new CDP4Common.EngineeringModelData.File(Guid.NewGuid(), null, null); var fileRevision = new CDP4Common.EngineeringModelData.FileRevision(Guid.NewGuid(), null, null); fileRevision.ContentHash = "1B686ADFA2CAE870A96E5885087337C032781BE6"; - + transaction.Create(file, commonFileStoreClone); transaction.Create(fileRevision, file); var operationContainer = transaction.FinalizeTransaction(); - var files = new List {this.filePath}; + var files = new List { this.filePath }; var testDal = new TestDal(this.credentials); @@ -300,10 +301,13 @@ public void Verify_that_OperationContainerFileVerification_throws_no_exception_w } } - [CDPVersion("1.1.0")] + [CDPVersion("1.1.0")] internal class TestDal : Dal { - public override bool IsReadOnly { get { return false; } } + public override bool IsReadOnly + { + get { return false; } + } public TestDal(Credentials credentials) : base() @@ -410,7 +414,7 @@ public override IEnumerable Update(T thing) { throw new System.NotImplementedException(); } - + public override IEnumerable Delete(T thing) { throw new System.NotImplementedException(); @@ -447,10 +451,11 @@ public override Task> CherryPick(Guid engineeringModelId, Gui } } - [DalExportAttribute("decorateddal","a decorated dal","1.1.0",DalType.Web)] + [DalExportAttribute("decorateddal", "a decorated dal", "1.1.0", DalType.Web)] internal class DecoratedDal : Dal { public override bool IsReadOnly { get; } + public override Task> Write(IEnumerable operationContainer, IEnumerable files = null) { throw new NotImplementedException(); @@ -566,4 +571,4 @@ public override Task> CherryPick(Guid engineeringModelId, Gui throw new NotSupportedException(); } } -} \ No newline at end of file +} diff --git a/CDP4Dal.Tests/Operations/OperationContainerTestFixture.cs b/CDP4Dal.Tests/Operations/OperationContainerTestFixture.cs index a24abc35..27722f0e 100644 --- a/CDP4Dal.Tests/Operations/OperationContainerTestFixture.cs +++ b/CDP4Dal.Tests/Operations/OperationContainerTestFixture.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Tests { @@ -28,10 +28,14 @@ namespace CDP4Dal.Tests using System.Linq; using CDP4Common.CommonData; - using CDP4Common.DTO; + using CDP4Common.DTO; + using CDP4Dal.Operations; + + using CDP4DalCommon.Protocol.Operations; + using NUnit.Framework; - + [TestFixture] public class OperationContainerTestFixture { @@ -42,7 +46,7 @@ public class OperationContainerTestFixture [SetUp] public void SetUp() { - this.siteDirectoryContext = "/SiteDirectory/47363f0d-eb6d-4a58-95f5-fa7854995650"; + this.siteDirectoryContext = "/SiteDirectory/47363f0d-eb6d-4a58-95f5-fa7854995650"; this.iterationContext = "/EngineeringModel/5e5dc7f8-833d-4331-b421-eb2c64fcf64b/iteration/b58ea73d-350d-4520-b9d9-a52c75ac2b5d"; } @@ -98,9 +102,9 @@ public void VerifyExecutionOfOperationAddAndRemove() var elementDefinition = new ElementDefinition(Guid.NewGuid(), 0); elementDefinition.PartialRoutes.Add("iteration/b58ea73d-350d-4520-b9d9-a52c75ac2b5d"); elementDefinition.PartialRoutes.Add("EngineeringModel/5e5dc7f8-833d-4331-b421-eb2c64fcf64b"); - + var clone = elementDefinition.DeepClone(); - var operation = new Operation(elementDefinition, clone, OperationKind.Update); + var operation = new Operation(elementDefinition, clone, OperationKind.Update); var operationContainer = new OperationContainer(this.iterationContext); diff --git a/CDP4Dal.Tests/Operations/OperationTestFixture.cs b/CDP4Dal.Tests/Operations/OperationTestFixture.cs index f0e46dd6..fb6565ed 100644 --- a/CDP4Dal.Tests/Operations/OperationTestFixture.cs +++ b/CDP4Dal.Tests/Operations/OperationTestFixture.cs @@ -1,32 +1,32 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Tests { using CDP4Common.DTO; - using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; using NUnit.Framework; diff --git a/CDP4Dal.Tests/Operations/PostOperationTestFixture.cs b/CDP4Dal.Tests/Operations/PostOperationTestFixture.cs index 6da8350c..7ab265d9 100644 --- a/CDP4Dal.Tests/Operations/PostOperationTestFixture.cs +++ b/CDP4Dal.Tests/Operations/PostOperationTestFixture.cs @@ -1,35 +1,37 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- - -using CDP4Common; +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Tests { using System.Collections.Generic; + + using CDP4Common; using CDP4Common.Dto; using CDP4Common.DTO; - using CDP4Dal.Operations; + + using CDP4DalCommon.Protocol.Operations; + using NUnit.Framework; [TestFixture] @@ -49,9 +51,13 @@ public void VerifyThatConstructorSetsLists() internal class TestPostOperation : PostOperation { public override List Delete { get; set; } + public override List Create { get; set; } + public override List Update { get; set; } + public override List Copy { get; set; } + public override void ConstructFromOperation(Operation operation) { throw new System.NotImplementedException(); diff --git a/CDP4Dal.Tests/Operations/ThingTransactionTestFixture.cs b/CDP4Dal.Tests/Operations/ThingTransactionTestFixture.cs index 4ed2d35c..d3055811 100644 --- a/CDP4Dal.Tests/Operations/ThingTransactionTestFixture.cs +++ b/CDP4Dal.Tests/Operations/ThingTransactionTestFixture.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Tests { @@ -31,12 +31,14 @@ namespace CDP4Dal.Tests using System.Text; using CDP4Common.CommonData; - using CDP4Common.EngineeringModelData; + using CDP4Common.EngineeringModelData; using CDP4Common.SiteDirectoryData; using CDP4Common.Types; - + using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + using NUnit.Framework; /// @@ -50,8 +52,8 @@ public class ThingTransactionTestFixture private Iteration iteration; private ConcurrentDictionary> cache; - private Uri uri = new Uri("http://www.stariongroup.eu"); - + private Uri uri = new Uri("http://www.rheagroup.com"); + [SetUp] public void Setup() { @@ -65,7 +67,7 @@ public void Setup() iterationSetup.IterationIid = this.iteration.Iid; this.engineeringModel.Iteration.Add(this.iteration); - + this.cache.TryAdd(new CacheKey(this.siteDirectory.Iid, null), new Lazy(() => this.siteDirectory)); this.cache.TryAdd(new CacheKey(this.engineeringModel.Iid, null), new Lazy(() => this.engineeringModel)); this.cache.TryAdd(new CacheKey(this.iteration.Iid, null), new Lazy(() => this.iteration)); @@ -95,7 +97,7 @@ public void VerifyThatCanOnlyUseThingTransactionOnOneTopContainer() var person = new Person(Guid.NewGuid(), this.cache, this.uri) { Container = this.siteDirectory }; var transaction = new ThingTransaction(transactionContext, person); - + var duplicateSiteDirectory = new SiteDirectory(this.siteDirectory.Iid, this.cache, this.uri); var anotherPerson = new Person(Guid.NewGuid(), this.cache, this.uri) { Container = duplicateSiteDirectory }; transaction.CreateOrUpdate(anotherPerson); @@ -109,7 +111,7 @@ public void VerifyThatCanOnlyUseThingTransactionOnOneTopContainer() [Test] public void VerifyThatCreateThingWorks() { - var person = new Person(Guid.NewGuid(), this.cache, this.uri) {Container = this.siteDirectory}; + var person = new Person(Guid.NewGuid(), this.cache, this.uri) { Container = this.siteDirectory }; this.cache.TryAdd(new CacheKey(person.Iid, null), new Lazy(() => person)); var clonePerson = person.Clone(false); @@ -131,6 +133,7 @@ public void VerifyThatCreateThingWorksWithAbstractContainer() { Container = this.siteDirectory }; + this.cache.TryAdd(new CacheKey(siteRdl.Iid, null), new Lazy(() => siteRdl)); var cloneRdl = siteRdl.Clone(false); @@ -152,7 +155,7 @@ public void VerifyThatCreateModelDoesNotWorks() var newModel = new EngineeringModel(Guid.NewGuid(), this.cache, this.uri); var transactionContext = TransactionContextResolver.ResolveContext(this.siteDirectory); - + Assert.Throws(() => new ThingTransaction(transactionContext, newModel)); } @@ -162,7 +165,7 @@ public void VerifyThatCreateSiteDirDoesNotWorks() var newSiteDirectory = new SiteDirectory(Guid.NewGuid(), this.cache, this.uri); var transactionContext = TransactionContextResolver.ResolveContext(this.siteDirectory); - + Assert.Throws(() => new ThingTransaction(transactionContext, newSiteDirectory)); } @@ -195,7 +198,7 @@ public void VerifyThatUpdateThingWorks() { var phone = new TelephoneNumber(Guid.NewGuid(), this.cache, this.uri); this.cache.TryAdd(new CacheKey(phone.Iid, null), new Lazy(() => phone)); - + var clone = phone.Clone(false); var transactionContext = TransactionContextResolver.ResolveContext(this.siteDirectory); @@ -208,9 +211,9 @@ public void VerifyThatUpdateThingWorks() [Test] public void VerifyThatUpdateThingThrowsExceptionUponUpdatingExistingCloneWithAnotherClone() { - var phone = new TelephoneNumber(Guid.NewGuid(), this.cache, this.uri); + var phone = new TelephoneNumber(Guid.NewGuid(), this.cache, this.uri); this.cache.TryAdd(new CacheKey(phone.Iid, null), new Lazy(() => phone)); - + var clone1 = phone.Clone(false); var clone2 = phone.Clone(false); @@ -246,10 +249,9 @@ public void VerifyThatDeleteThingAlreadyDeletedWorks() [Test] public void VerifyThatUpdateContainerWorks() { - var iterationClone = this.iteration.Clone(false); var option1 = new Option(Guid.NewGuid(), this.cache, this.uri); - + var transactionContext = TransactionContextResolver.ResolveContext(this.iteration); var transaction = new ThingTransaction(transactionContext, iterationClone); transaction.CreateOrUpdate(iterationClone); @@ -272,7 +274,7 @@ public void VerifyThatUpdateContainerWorks() Assert.That(0, Is.EqualTo(this.iteration.Option.Count)); Assert.That(2, Is.EqualTo(clone.Option.Count)); } - + /// /// Create a containment tree under site directory and update /// @@ -328,6 +330,7 @@ public void FunctionalTestCase1() emailTrans.Create(email); emailTrans.FinalizeSubTransaction(email, person1_1); + // end add email, verify that email is added to person1_1, (the clone of person1) Assert.That(2, Is.EqualTo(person1_1Tr.AddedThing.Count())); @@ -339,6 +342,7 @@ public void FunctionalTestCase1() var phone_1Trans = new ThingTransaction(phone_1, person1_1Tr, person1_1); phone_1Trans.CreateOrUpdate(phone_1); phone_1Trans.FinalizeSubTransaction(phone_1, person1_1); + // end update phone // verify that the new reference is used @@ -577,7 +581,7 @@ public void VerifyThatCreateDeepWorks() enumValue.Definition.Add(enumValueDef); enumPt.ValueDefinition.Add(enumValue); - + var transactionContext = TransactionContextResolver.ResolveContext(this.siteDirectory); var transaction = new ThingTransaction(transactionContext); transaction.CreateDeep(enumPt); @@ -827,6 +831,7 @@ public void VerifyThatCascadeDeleteWorksOnAddedThing() transaction.Delete(person.Clone(false)); var operationContainer = transaction.FinalizeTransaction(); + // Update sitedir Assert.That(1, Is.EqualTo(operationContainer.Operations.Count())); } @@ -852,8 +857,8 @@ public void VerifyThatDryCopyWorks() var elementDefinitionClone = elementDefinition.Clone(false); var targetIterationClone = targetIteration.Clone(false); - - var transactionContext = TransactionContextResolver.ResolveContext(targetIteration); + + var transactionContext = TransactionContextResolver.ResolveContext(targetIteration); var transaction = new ThingTransaction(transactionContext); transaction.Copy(elementDefinitionClone, targetIterationClone, OperationKind.CopyDefaultValuesChangeOwner); @@ -886,7 +891,7 @@ public void VerifyThatCtrlCopyWorks() var elementDefinitionClone = elementDefinition.Clone(false); var targetIterationClone = targetIteration.Clone(false); - + var transactionContext = TransactionContextResolver.ResolveContext(targetIteration); var transaction = new ThingTransaction(transactionContext); transaction.Copy(elementDefinitionClone, targetIterationClone, OperationKind.CopyKeepValuesChangeOwner); @@ -994,7 +999,7 @@ public void VerifyThatWhenCopyOperationIsInvokedWithNonCopyOperationExceptionIsT Assert.Throws(() => transaction.Copy(elementDefinitionClone, targetIterationClone, OperationKind.Create)); } - [Test] + [Test] public void VerifyThatCopyThrowsExcpetionCloneThatIsToBeCopiedIsNull() { var sourceModel = new EngineeringModel(Guid.NewGuid(), this.cache, this.uri); @@ -1019,7 +1024,7 @@ public void VerifyThatCopyThrowsExcpetionCloneThatIsToBeCopiedIsNull() Assert.Throws(() => transaction.Copy(null, OperationKind.Copy)); } - [Test] + [Test] public void VerifyThatCopyThrowsExceptionWhenDestinationIsNull() { var sourceModel = new EngineeringModel(Guid.NewGuid(), this.cache, this.uri); @@ -1050,9 +1055,9 @@ public void VerifyThatGetLastCloneCreatedThrowsExceptionWhenThingIsNullOrGuidIsE { var model = new EngineeringModel(Guid.NewGuid(), this.cache, this.uri); var iteration = new Iteration(Guid.NewGuid(), this.cache, this.uri); - + model.Iteration.Add(iteration); - + var transactionContext = TransactionContextResolver.ResolveContext(iteration); var transaction = new ThingTransaction(transactionContext); @@ -1066,9 +1071,9 @@ public void VerifyThatGetLastCloneCreatedThrowsExceptionWhenThingIsNullOrGuidIsE [Test] public void VerifyThatArgumentNullExceptionIsThrownWhenContextIsNull() { - Assert.Throws(() => new ThingTransaction(null)); + Assert.Throws(() => new ThingTransaction(null)); } - + [Test] public void VerifyThatArgumentNullExceptionIsThrownWhenCloneIsNull() { @@ -1084,7 +1089,7 @@ public void VerifyThatArgumentNullExceptionIsThrownWhenCloneIsNull() var iterationClone = iteration.Clone(false); var elementDefinitionClone = elementDefinition.Clone(false); - Assert.Throws(() => new ThingTransaction(null, null, iterationClone)); + Assert.Throws(() => new ThingTransaction(null, null, iterationClone)); } } } diff --git a/CDP4Dal.Tests/SessionTestFixture.cs b/CDP4Dal.Tests/SessionTestFixture.cs index fbce8625..490d3c9c 100644 --- a/CDP4Dal.Tests/SessionTestFixture.cs +++ b/CDP4Dal.Tests/SessionTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Tests { @@ -37,12 +37,12 @@ namespace CDP4Dal.Tests using CDP4Common.Types; using CDP4Dal.Composition; - using CDP4Dal.Operations; using CDP4Dal.DAL; using CDP4Dal.Events; using CDP4Dal.Exceptions; + using CDP4Dal.Operations; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Tasks; using Moq; @@ -130,10 +130,7 @@ public void TearDown() public async Task VerifythatOpenCallAssemblerSynchronizeWithDtos() { var eventReceived = false; - this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => - { - eventReceived = true; - }); + this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => { eventReceived = true; }); await this.session.Open(); @@ -178,10 +175,7 @@ public void VerifyThatOpenCallMightBeCancelled() })); } - Assert.DoesNotThrowAsync(async () => - { - await Task.WhenAll(tasks.ToArray()); - }); + Assert.DoesNotThrowAsync(async () => { await Task.WhenAll(tasks.ToArray()); }); } [Test] @@ -196,18 +190,18 @@ public async Task VerifyThatWriteWithEmptyResponseSendsMessages() this.messageBus.Listen() .Subscribe(x => - { - if (x.Status == SessionStatus.BeginUpdate) { - beginUpdateReceived = true; - return; - } + if (x.Status == SessionStatus.BeginUpdate) + { + beginUpdateReceived = true; + return; + } - if (x.Status == SessionStatus.EndUpdate) - { - endUpdateReceived = true; - } - }); + if (x.Status == SessionStatus.EndUpdate) + { + endUpdateReceived = true; + } + }); var context = $"/SiteDirectory/{Guid.NewGuid()}"; @@ -234,10 +228,7 @@ public async Task VerifythatRefreshSynchronizeTheAssembler() await this.session.Open(); - this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => - { - eventReceived = true; - }); + this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => { eventReceived = true; }); // refresh shouldnt do anything await this.session.Refresh(); @@ -267,10 +258,7 @@ public async Task VerifythatReloadSynchronizeTheAssembler() await this.session.Open(); - this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => - { - eventReceived = true; - }); + this.messageBus.Listen(typeof(TelephoneNumber)).Subscribe(x => { eventReceived = true; }); await this.session.Reload(); @@ -467,14 +455,15 @@ public async Task VerifyThatSiteRdlRequiredByModelRdlCannotBeClosed() var participant = new CDP4Common.DTO.Participant(Guid.NewGuid(), 0) { Person = this.person.Iid }; modelsetup.Participant.Add(participant.Iid); - var modelPoco = new CDP4Common.EngineeringModelData.EngineeringModel(model.Iid, null, null){EngineeringModelSetup = modelsetuppoco}; + var modelPoco = new CDP4Common.EngineeringModelData.EngineeringModel(model.Iid, null, null) { EngineeringModelSetup = modelsetuppoco }; var iterationPoco = new CDP4Common.EngineeringModelData.Iteration(iteration.Iid, null, null); modelPoco.Iteration.Add(iterationPoco); var readTaskCompletionSource = new TaskCompletionSource>(); readTaskCompletionSource.SetResult(readReturn); + this.mockedDal.Setup( - x => x.Read(It.IsAny(), It.IsAny(), null)) + x => x.Read(It.IsAny(), It.IsAny(), null)) .Returns(readTaskCompletionSource.Task); var thingsToAdd = new List() { siteDirDto, requiredRdlDto, rdlDto, this.person, participant, modelsetup }; @@ -568,6 +557,7 @@ public async Task VerifyThatReadRdlWorks() { var siteDir = new CDP4Common.SiteDirectoryData.SiteDirectory(Guid.NewGuid(), this.session.Assembler.Cache, this.uri); var JohnDoe = new CDP4Common.SiteDirectoryData.Person(this.person.Iid, this.session.Assembler.Cache, this.uri) { ShortName = "John" }; + this.session.Assembler.Cache.TryAdd(new CacheKey(siteDir.Iid, null), new Lazy(() => siteDir)); @@ -599,7 +589,7 @@ public async Task VerifyThatReadRdlWorks() public async Task VerifyThatReadIterationWorks() { var siteDir = new CDP4Common.SiteDirectoryData.SiteDirectory(Guid.NewGuid(), this.session.Assembler.Cache, this.uri); - var JohnDoe = new CDP4Common.SiteDirectoryData.Person(this.person.Iid, this.session.Assembler.Cache, this.uri) {ShortName = "John"}; + var JohnDoe = new CDP4Common.SiteDirectoryData.Person(this.person.Iid, this.session.Assembler.Cache, this.uri) { ShortName = "John" }; var modelSetup = new CDP4Common.SiteDirectoryData.EngineeringModelSetup(Guid.NewGuid(), this.session.Assembler.Cache, this.uri); var iterationSetup = new CDP4Common.SiteDirectoryData.IterationSetup(Guid.NewGuid(), this.session.Assembler.Cache, this.uri) { FrozenOn = DateTime.Now, IterationIid = Guid.NewGuid() }; var mrdl = new ModelReferenceDataLibrary(Guid.NewGuid(), this.session.Assembler.Cache, this.uri); @@ -738,10 +728,7 @@ public async Task VerifyThatWriteWorksWithEventHandler() var johnDoe = new CDP4Common.SiteDirectoryData.Person(this.person.Iid, this.session.Assembler.Cache, this.uri) { ShortName = "John" }; this.session.GetType().GetProperty("ActivePerson")?.SetValue(this.session, johnDoe, null); - this.session.BeforeWrite += (o, args) => - { - args.Cancelled = false; - }; + this.session.BeforeWrite += (o, args) => { args.Cancelled = false; }; await this.session.Write(new OperationContainer(context)); @@ -755,10 +742,7 @@ public void VerifyThatCancelWriteWorks() var johnDoe = new CDP4Common.SiteDirectoryData.Person(this.person.Iid, this.session.Assembler.Cache, this.uri) { ShortName = "John" }; this.session.GetType().GetProperty("ActivePerson")?.SetValue(this.session, johnDoe, null); - this.session.BeforeWrite += (o, args) => - { - args.Cancelled = true; - }; + this.session.BeforeWrite += (o, args) => { args.Cancelled = true; }; Assert.ThrowsAsync(async () => await this.session.Write(new OperationContainer(context))); @@ -784,11 +768,11 @@ public async Task VerifyCanCherryPick() categoriesId.Add(Guid.NewGuid()); var elementDefinitionId = Guid.NewGuid(); - cherryPickedThings.Add(new Iteration(){Iid = engineeringModelId, Element = new List{elementDefinitionId}}); - cherryPickedThings.Add(new ElementDefinition(){Iid = elementDefinitionId, Category = new List { categoriesId[0] }}); + cherryPickedThings.Add(new Iteration() { Iid = engineeringModelId, Element = new List { elementDefinitionId } }); + cherryPickedThings.Add(new ElementDefinition() { Iid = elementDefinitionId, Category = new List { categoriesId[0] } }); readThings = (await this.session.CherryPick(engineeringModelId, iterationId, classKinds, categoriesId)).ToList(); - + Assert.Multiple(() => { Assert.That(readThings, Is.Not.Empty); @@ -893,7 +877,7 @@ public async Task VerifyWritePossibleLongRunningTask() this.mockedDal.Setup(x => x.Write(It.IsAny(), It.IsAny(), It.IsAny>())) .ReturnsAsync(new LongRunningTaskResult(new CometTask() { Id = Guid.Empty })); - + var cometTask = await this.session.Write(new OperationContainer(context), 1); Assert.Multiple(() => @@ -922,8 +906,9 @@ public async Task VerifyWritePossibleLongRunningTask() this.mockedDal.Setup(x => x.Write(It.IsAny(), It.IsAny(), It.IsAny>())) .ThrowsAsync(new DalReadException()); - Assert.That(() =>this.session.Write(new OperationContainer(context), 1), Throws.Exception.TypeOf()); + Assert.That(() => this.session.Write(new OperationContainer(context), 1), Throws.Exception.TypeOf()); } + private void AssignActivePerson() { var johnDoe = new Person(this.person.Iid, this.session.Assembler.Cache, this.uri) { ShortName = "John" }; @@ -934,16 +919,30 @@ private void AssignActivePerson() [DalExport("test dal", "test dal description", "1.1.0", DalType.Web)] internal class TestDal : IDal { - public Version SupportedVersion { get {return new Version(1, 0, 0);} } - public Version DalVersion { get {return new Version("1.1.0");} } - public IMetaDataProvider MetaDataProvider { get {return new MetaDataProvider();} } + public Version SupportedVersion + { + get { return new Version(1, 0, 0); } + } + + public Version DalVersion + { + get { return new Version("1.1.0"); } + } + + public IMetaDataProvider MetaDataProvider + { + get { return new MetaDataProvider(); } + } /// /// Gets or sets the that uses this /// public ISession Session { get; set; } - public bool IsReadOnly { get { return false; } } + public bool IsReadOnly + { + get { return false; } + } /// /// Write all the s from all the s asynchronously. @@ -1184,4 +1183,4 @@ public Task> CherryPick(Guid engineeringModelId, Guid iterati throw new NotImplementedException(); } } -} \ No newline at end of file +} diff --git a/CDP4Dal/DAL/Dal.cs b/CDP4Dal/DAL/Dal.cs index fb562484..425bf12e 100644 --- a/CDP4Dal/DAL/Dal.cs +++ b/CDP4Dal/DAL/Dal.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of COMET-SDK Community Edition -// -// The COMET-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The COMET-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.DAL { @@ -36,15 +36,16 @@ namespace CDP4Dal.DAL using CDP4Common.DTO; using CDP4Common.Helpers; using CDP4Common.MetaInfo; - - using CDP4Dal.Operations; + using CDP4Dal.Composition; using CDP4Dal.Exceptions; + using CDP4Dal.Operations; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Operations; + using CDP4DalCommon.Protocol.Tasks; using NLog; - + using Iteration = CDP4Common.DTO.Iteration; using Thing = CDP4Common.DTO.Thing; @@ -217,7 +218,7 @@ protected Dal() /// The /// /// an await-able that returns a array. - public abstract Task ReadFile(Thing thing, CancellationToken cancellationToken) ; + public abstract Task ReadFile(Thing thing, CancellationToken cancellationToken); /// /// Creates the specified on a data source @@ -438,7 +439,7 @@ public bool TryExtractIterationIdfromUri(Uri uri, out Guid iterationId) } catch (Exception ex) { - Logger.Warn(ex,"The Iteration identifier could not be exracted from {0}", uri); + Logger.Warn(ex, "The Iteration identifier could not be exracted from {0}", uri); iterationId = Guid.Empty; return false; @@ -543,4 +544,4 @@ protected virtual void SetCdpVersion() } } } -} \ No newline at end of file +} diff --git a/CDP4Dal/DAL/IDal.cs b/CDP4Dal/DAL/IDal.cs index 0ff6a7f3..179a4935 100644 --- a/CDP4Dal/DAL/IDal.cs +++ b/CDP4Dal/DAL/IDal.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.DAL { @@ -35,7 +35,8 @@ namespace CDP4Dal.DAL using CDP4Dal.Operations; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Operations; + using CDP4DalCommon.Protocol.Tasks; using Thing = CDP4Common.DTO.Thing; @@ -63,7 +64,7 @@ public interface IDal /// Gets the value indicating whether this is read only /// bool IsReadOnly { get; } - + /// /// Write all the s from all the s asynchronously. /// @@ -91,7 +92,7 @@ public interface IDal /// A list of s that has been created or updated since the last Read or Write operation. /// Task> Write(OperationContainer operationContainer, IEnumerable files = null); - + /// /// Write all the s from an asynchronously for a possible long running task. /// @@ -276,7 +277,7 @@ public interface IDal /// A collection of s /// The /// A of type of read - Task> CherryPick(Guid engineeringModelId, Guid iterationId, IEnumerable classKinds, + Task> CherryPick(Guid engineeringModelId, Guid iterationId, IEnumerable classKinds, IEnumerable categoriesId, CancellationToken cancellationToken); } -} \ No newline at end of file +} diff --git a/CDP4Dal/Exceptions/InvalidOperationContainerException.cs b/CDP4Dal/Exceptions/InvalidOperationContainerException.cs index 5240da47..3f076b8e 100644 --- a/CDP4Dal/Exceptions/InvalidOperationContainerException.cs +++ b/CDP4Dal/Exceptions/InvalidOperationContainerException.cs @@ -1,21 +1,21 @@ // ------------------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexandervan Delft, Nathanael Smiechowski, Ahmed Abulwafa Ahmed -// -// This file is part of COMET-SDK Community Edition -// -// The COMET-SDK Community Edition is free software; you can redistribute it and/or +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The COMET-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. @@ -28,6 +28,8 @@ namespace CDP4Dal.Exceptions using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + /// /// A is thrown when an is invalid or incomplete, /// or one of the contained s is invalid or incomplete. diff --git a/CDP4Dal/Exceptions/InvalidOperationKindException.cs b/CDP4Dal/Exceptions/InvalidOperationKindException.cs index 21fc6d12..f12cbda6 100644 --- a/CDP4Dal/Exceptions/InvalidOperationKindException.cs +++ b/CDP4Dal/Exceptions/InvalidOperationKindException.cs @@ -1,21 +1,21 @@ // ------------------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexandervan Delft, Nathanael Smiechowski, Ahmed Abulwafa Ahmed -// -// This file is part of COMET-SDK Community Edition -// -// The COMET-SDK Community Edition is free software; you can redistribute it and/or +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The COMET-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. @@ -28,9 +28,11 @@ namespace CDP4Dal.Exceptions using CDP4Dal.DAL; + using CDP4DalCommon.Protocol.Operations; + /// /// A InvalidOperationKindException is thrown whenever an contains - /// that are not supported by the implementation of an + /// that are not supported by the implementation of an /// public class InvalidOperationKindException : Exception { diff --git a/CDP4Dal/ISession.cs b/CDP4Dal/ISession.cs index 8f301402..f86464cd 100644 --- a/CDP4Dal/ISession.cs +++ b/CDP4Dal/ISession.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal { @@ -34,13 +34,13 @@ namespace CDP4Dal using CDP4Common.ExceptionHandlerService; using CDP4Common.SiteDirectoryData; - using CDP4Dal.Operations; using CDP4Dal.DAL; using CDP4Dal.Events; + using CDP4Dal.Operations; + using CDP4Dal.Permission; - using CDP4DalCommon.Tasks; - - using Permission; + using CDP4DalCommon.Protocol.Operations; + using CDP4DalCommon.Protocol.Tasks; /// /// The interface encapsulates an and @@ -56,7 +56,7 @@ public interface ISession /// /// Gets the that are use to connect to the data source /// - Credentials Credentials { get; } + Credentials Credentials { get; } /// /// Gets all the s that the active person is linked with. @@ -112,7 +112,7 @@ public interface ISession /// /// Gets the name of the session which is the concatentation of the data-source uri and the active person /// - string Name { get; } + string Name { get; } /// /// Gets the list of that are currently open in the running application. @@ -122,7 +122,7 @@ public interface ISession /// /// Gets the list of s that are currently open with the active and /// - IReadOnlyDictionary > OpenIterations { get; } + IReadOnlyDictionary> OpenIterations { get; } /// /// Gets the that handles messaging for this session diff --git a/CDP4Dal/Operations/IThingTransaction.cs b/CDP4Dal/Operations/IThingTransaction.cs index 6d04848c..664098d1 100644 --- a/CDP4Dal/Operations/IThingTransaction.cs +++ b/CDP4Dal/Operations/IThingTransaction.cs @@ -1,35 +1,38 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Operations { using System; using System.Collections.Generic; + using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.Types; + using CDP4DalCommon.Protocol.Operations; + /// /// The interface operations /// @@ -190,4 +193,4 @@ public interface IThingTransaction /// The sub- void Merge(IThingTransaction subTransaction); } -} \ No newline at end of file +} diff --git a/CDP4Dal/Operations/LongRunningTaskResult.cs b/CDP4Dal/Operations/LongRunningTaskResult.cs index d9e6bf8d..19c1221b 100644 --- a/CDP4Dal/Operations/LongRunningTaskResult.cs +++ b/CDP4Dal/Operations/LongRunningTaskResult.cs @@ -2,7 +2,7 @@ // // Copyright (c) 2015-2024 Starion Group S.A. // -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -28,7 +28,7 @@ namespace CDP4Dal.Operations using CDP4Common.DTO; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Tasks; /// /// Handle the returned data of a possible long running task diff --git a/CDP4Dal/Operations/OperationContainer.cs b/CDP4Dal/Operations/OperationContainer.cs index 86b6b785..2b66a7a9 100644 --- a/CDP4Dal/Operations/OperationContainer.cs +++ b/CDP4Dal/Operations/OperationContainer.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Operations { @@ -30,6 +30,8 @@ namespace CDP4Dal.Operations using CDP4Common.DTO; using CDP4Common.Helpers; + using CDP4DalCommon.Protocol.Operations; + /// /// A container for the s that need to be executed on a data source using an implementation of /// @@ -62,7 +64,7 @@ public OperationContainer(string context, int? topContainerRevNumber = null) this.Token = TokenGenerator.GenerateRandomToken(); this.Context = context; - + this.operations = new List(); this.TopContainerRevisionNumber = topContainerRevNumber; } @@ -94,10 +96,7 @@ public OperationContainer(string context, int? topContainerRevNumber = null) /// public IEnumerable Operations { - get - { - return this.operations; - } + get { return this.operations; } } /// @@ -136,7 +135,7 @@ private void ValidateContextOfOperation(Operation operation) /// public void RemoveOperation(Operation operation) { - this.operations.Remove(operation); + this.operations.Remove(operation); } } -} \ No newline at end of file +} diff --git a/CDP4Dal/Operations/OperationKindExtensions.cs b/CDP4Dal/Operations/OperationKindExtensions.cs index 8cdb6748..f3b75c50 100644 --- a/CDP4Dal/Operations/OperationKindExtensions.cs +++ b/CDP4Dal/Operations/OperationKindExtensions.cs @@ -1,31 +1,33 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Nathanael Smiechowski -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Operations { using CDP4Common.DTO; + using CDP4DalCommon.Protocol.Operations; + /// /// Utils class to provide OperationKind Extensions to CDP4Dal /// diff --git a/CDP4Dal/Operations/ThingTransaction.cs b/CDP4Dal/Operations/ThingTransaction.cs index bc6cb475..8b74fb5c 100644 --- a/CDP4Dal/Operations/ThingTransaction.cs +++ b/CDP4Dal/Operations/ThingTransaction.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details.copy -// +// Lesser General Public License for more details. +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal.Operations { @@ -31,15 +31,17 @@ namespace CDP4Dal.Operations using System.Reflection; using CDP4Common; + using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.Extensions; using CDP4Common.Polyfills; using CDP4Common.SiteDirectoryData; - using CDP4Common.CommonData; using CDP4Common.Types; using CDP4Dal.Exceptions; + using CDP4DalCommon.Protocol.Operations; + using NLog; /// @@ -92,10 +94,10 @@ public class ThingTransaction : IThingTransaction /// public ThingTransaction(TransactionContext transactionContext, Thing clone = null) { - this.TransactionContext = - transactionContext ?? + this.TransactionContext = + transactionContext ?? throw new ArgumentNullException(nameof(transactionContext), $"The {nameof(transactionContext)} may not be null"); - + this.addedThing = new List(); this.updatedThing = new Dictionary(); this.deletedThing = new List(); @@ -137,7 +139,7 @@ public ThingTransaction(Thing clone, IThingTransaction parentTransaction, Thing { throw new ArgumentNullException(nameof(clone), $"The {nameof(clone)} may not be null."); } - + this.TransactionContext = parentTransaction.TransactionContext; this.addedThing = new List(); @@ -299,18 +301,19 @@ public void CreateOrUpdate(Thing clone) throw new ArgumentNullException(nameof(clone), $"The {nameof(clone)} may not be null"); } - if(this.UpdatedThing.Values.Any(x => x == clone) || this.AddedThing.Any(x => x == clone)) + if (this.UpdatedThing.Values.Any(x => x == clone) || this.AddedThing.Any(x => x == clone)) { return; } - if(this.UpdatedThing.Values.Any(x => x.Iid == clone.Iid) || this.AddedThing.Any(x => x.Iid == clone.Iid)) + if (this.UpdatedThing.Values.Any(x => x.Iid == clone.Iid) || this.AddedThing.Any(x => x.Iid == clone.Iid)) { return; } var UpdatedThing = this.GetUpdatedThing(clone); - if(UpdatedThing != null) + + if (UpdatedThing != null) { if (clone.Iid == Guid.Empty) { @@ -337,7 +340,7 @@ public void Delete(Thing clone, Thing containerClone = null) { throw new ArgumentNullException(nameof(clone), $"The {nameof(clone)} may not be null."); } - + if (this.DeletedThing.Any(x => x.Iid == clone.Iid)) { return; @@ -363,6 +366,7 @@ public void Delete(Thing clone, Thing containerClone = null) { // remove potential reference from the list of updated thing in the current transaction var updatedThingKey = this.UpdatedThing.Keys.SingleOrDefault(x => x.Iid == clone.Iid); + if (updatedThingKey != null) { this.updatedThing.Remove(updatedThingKey); @@ -375,6 +379,7 @@ public void Delete(Thing clone, Thing containerClone = null) { // remove from the list of added thing var thingInAddedList = this.AddedThing.SingleOrDefault(x => x.Iid == clone.Iid); + if (thingInAddedList != null) { this.addedThing.Remove(thingInAddedList); @@ -434,7 +439,7 @@ public void Copy(Thing clone, OperationKind operationKind) { throw new ArgumentException("The copy operation may only be performed with Copy or CopyDefaultValuesChangeOwner or CopyKeepValues or CopyKeepValuesChangeOwner", nameof(operationKind)); } - + var original = this.GetUpdatedThing(clone); // setting a new iid for the copy @@ -445,7 +450,7 @@ public void Copy(Thing clone, OperationKind operationKind) { return; } - + // setting a new iid for the copy clone.Iid = Guid.NewGuid(); this.copiedThing.Add(originalCopyPair, operationKind); @@ -469,13 +474,14 @@ public Thing GetClone(Thing thing) } var clone = this.UpdatedThing.Values.SingleOrDefault(x => x.Iid == thing.Iid); + if (clone != null) { return clone; } clone = this.AddedThing.SingleOrDefault(x => x.Iid == thing.Iid); - + return clone; } @@ -498,6 +504,7 @@ public Thing GetLastCloneCreated(Thing thing) var allAddedThing = this.GetAllAddedThings().ToList(); var clone = allAddedThing.SingleOrDefault(x => x.Iid == thing.Iid); + if (clone != null) { return clone; @@ -505,7 +512,7 @@ public Thing GetLastCloneCreated(Thing thing) var allUpdatedThing = this.GetAllUpdatedThings().ToList(); clone = allUpdatedThing.SingleOrDefault(x => x.Iid == thing.Iid); - + return clone; } @@ -549,8 +556,8 @@ public void FinalizeSubTransaction(Thing clone, Thing containerclone, Thing next foreach ( var addedThing in - this.AddedThing.Where( - x => x != this.AssociatedClone && x.GetContainerInformation().Item1 == cloneTypeToUpdate)) + this.AddedThing.Where( + x => x != this.AssociatedClone && x.GetContainerInformation().Item1 == cloneTypeToUpdate)) { if (!addedThing.IsContainedBy(rootClone.Iid)) { @@ -560,6 +567,7 @@ var addedThing in // the clone should have been added var containerOfAddedThing = this.GetClone(addedThing.Container); + if (containerOfAddedThing == null) { throw new TransactionException("could not find the corresponding clone for the container of the added thing added outside the chain of transaction."); @@ -570,8 +578,8 @@ var addedThing in foreach ( var updatedThing in - this.UpdatedThing.Values.Where( - x => x != this.AssociatedClone && x.GetContainerInformation().Item1 == cloneTypeToUpdate)) + this.UpdatedThing.Values.Where( + x => x != this.AssociatedClone && x.GetContainerInformation().Item1 == cloneTypeToUpdate)) { if (!updatedThing.IsContainedBy(rootClone.Iid)) { @@ -581,6 +589,7 @@ var updatedThing in // the clone should have been added var containerOfUpdatedThing = this.GetClone(updatedThing.Container); + if (containerOfUpdatedThing == null) { throw new TransactionException( @@ -605,7 +614,7 @@ public OperationContainer FinalizeTransaction() } this.FilterOperationCausedByDelete(); - + var context = this.TransactionContext.ContextRoute(); var operationContainer = new OperationContainer(context, this.GetTopContainerRevisionNumber()); @@ -629,7 +638,7 @@ public string[] GetFiles() { if (string.IsNullOrWhiteSpace(thing.ContentHash)) { - throw new InvalidOperationException($"File {thing.LocalPath} cannot be saved because of an empty ContentHash" ); + throw new InvalidOperationException($"File {thing.LocalPath} cannot be saved because of an empty ContentHash"); } files.Add(thing.LocalPath); @@ -649,7 +658,8 @@ private Thing GetUpdatedThing(Thing clone) var allUpdatedThings = this.GetAllUpdatedThings().ToList(); var updatedThing = allUpdatedThings.SingleOrDefault(x => x.Iid == clone.Iid); - if(updatedThing != null) + + if (updatedThing != null) { if (updatedThing == clone) { @@ -662,6 +672,7 @@ private Thing GetUpdatedThing(Thing clone) // case2: the updated thing is already in the transaction as an added thing var allAddedThings = this.GetAllAddedThings().ToList(); updatedThing = allAddedThings.SingleOrDefault(x => x.Iid == clone.Iid); + if (updatedThing != null) { if (updatedThing == clone) @@ -681,6 +692,7 @@ private Thing GetUpdatedThing(Thing clone) // case3: the cache does not contain the key, its a new var lazy = clone.Cache.SingleOrDefault(x => Equals(x.Key, clone.CacheKey)).Value; + if (lazy == null) { return null; @@ -688,6 +700,7 @@ private Thing GetUpdatedThing(Thing clone) // case4: the updated thing is the original updatedThing = lazy.Value; + if (updatedThing == clone) { throw new InvalidOperationException("The transaction only accepts clones."); @@ -703,6 +716,7 @@ private Thing GetUpdatedThing(Thing clone) private IEnumerable GetAllAddedThings() { var allAddedThing = this.AddedThing.ToList(); + if (this.ParentTransaction != null) { this.PopulateAllAddedThingsList(this.ParentTransaction, allAddedThing); @@ -720,6 +734,7 @@ private void PopulateAllAddedThingsList(IThingTransaction transaction, List allAddedThing.All(y => y.Iid != x.Iid)); allAddedThing.AddRange(thingsToAdd); + if (transaction.ParentTransaction != null) { this.PopulateAllAddedThingsList(transaction.ParentTransaction, allAddedThing); @@ -733,6 +748,7 @@ private void PopulateAllAddedThingsList(IThingTransaction transaction, List GetAllUpdatedThings() { var allUpdatedThings = this.UpdatedThing.Values.ToList(); + if (this.ParentTransaction != null) { this.PopulateAllUpdatedThingsList(this.ParentTransaction, allUpdatedThings); @@ -750,6 +766,7 @@ private void PopulateAllUpdatedThingsList(IThingTransaction transaction, List allUpdatedThing.All(y => y.Iid != x.Iid)); allUpdatedThing.AddRange(thingsToAdd); + if (transaction.ParentTransaction != null) { this.PopulateAllUpdatedThingsList(transaction.ParentTransaction, allUpdatedThing); @@ -765,14 +782,15 @@ private void PopulateAllUpdatedThingsList(IThingTransaction transaction, List) }); + var findIndexMethod = containerProperty.PropertyType.GetMethod("FindIndex", new[] { typeof(Predicate) }); Predicate predicate = x => x.Iid == thing.Iid; - var index = (int)(findIndexMethod?.Invoke(containerList, new object[] { predicate })??-1); + var index = (int)(findIndexMethod?.Invoke(containerList, new object[] { predicate }) ?? -1); + if (index != -1) { // Get the indexer property, by default the indexer property name is "Item" @@ -809,6 +827,7 @@ private void UpdateOrderedItemList(Thing thing, Thing containerClone, Thing next Predicate predicate = x => x.Iid == thing.Iid; var index = (int)findIndexMethod.Invoke(containerList, new object[] { predicate }); + if (index != -1) { // Get the indexer property, by default the indexer property name is "Item" @@ -822,7 +841,7 @@ private void UpdateOrderedItemList(Thing thing, Thing containerClone, Thing next { // normal add var addMethod = orderedListProperty.PropertyType.GetMethod("Add"); - addMethod.Invoke(containerList, new object[] {thing}); + addMethod.Invoke(containerList, new object[] { thing }); } else { @@ -830,6 +849,7 @@ private void UpdateOrderedItemList(Thing thing, Thing containerClone, Thing next var indexOfMethod = orderedListProperty.PropertyType.GetMethod("IndexOf"); var index = indexOfMethod.Invoke(containerList, new object[] { nextThing }) as int?; + if (index == -1 || !index.HasValue) { throw new InvalidOperationException("The Thing before which the new item needs to be inserted does not exist."); @@ -850,14 +870,15 @@ private void UpdateOrderedItemList(Thing thing, Thing containerClone, Thing next private void RemoveThingFromContainer(Thing thing) { var containers = this.AddedThing.Concat(this.UpdatedThing.Values); - + var thingType = thing.GetType(); Thing originalThing = null; + if (thing.Cache != null && thing.Cache.ContainsKey(thing.CacheKey)) { var result = thing.Cache.TryGetValue(thing.CacheKey, out var lazyThing); - originalThing = (result)? lazyThing.Value : null; + originalThing = (result) ? lazyThing.Value : null; } // Find in all the thing in the transaction the potential container that contains the current thing @@ -877,7 +898,7 @@ private void RemoveThingFromContainer(Thing thing) var matchingPropertyInfos = containerType.GetProperties().Where(x => x.PropertyType.QueryIsGenericType() && (x.PropertyType.GetGenericTypeDefinition() == typeof(ContainerList<>) || - x.PropertyType.GetGenericTypeDefinition() == typeof(OrderedItemList<>)) && + x.PropertyType.GetGenericTypeDefinition() == typeof(OrderedItemList<>)) && x.PropertyType.GetGenericArguments().Single().QueryIsAssignableFrom(thingType)).ToList(); foreach (var propertyInfo in matchingPropertyInfos) @@ -886,6 +907,7 @@ private void RemoveThingFromContainer(Thing thing) var containerList = propertyInfo.GetValue(container) as IEnumerable; Thing thingToRemove = null; + foreach (Thing containedThing in containerList) { if (containedThing.Iid == thing.Iid) @@ -900,6 +922,7 @@ private void RemoveThingFromContainer(Thing thing) } var success = (bool)removeMethod.Invoke(containerList, new object[] { thingToRemove }); + if (success) { thingToRemove.Container = null; @@ -921,6 +944,7 @@ private void InitializeSubTransaction(ThingTransaction subTransaction, Thing con if (containerClone != null) { var currentContainertype = containerClone.GetType(); + if (!containerType.QueryIsAssignableFrom(currentContainertype)) { throw new InvalidOperationException("The specified container is not allowed as a container."); @@ -949,6 +973,7 @@ private void InitializeSubTransaction(ThingTransaction subTransaction, Thing con private void AddChainOfContainers(Thing clone) { var topOperationClone = this.GetOperationRootClone(); + if (!clone.IsContainedBy(topOperationClone.Iid)) { return; @@ -972,6 +997,7 @@ private void AddChainOfContainers(Thing clone) // add a new clone if newContainerClone is not contained by the current operation's chain of clones var containerType = transaction.AssociatedClone.GetType(); var container = clone.GetContainerOfType(containerType); + if (container == null) { return; @@ -992,6 +1018,7 @@ private Thing GetOperationRootClone() { var rootClone = this.AssociatedClone; var parent = this.ParentTransaction; + while (parent != null) { rootClone = parent.AssociatedClone ?? rootClone; @@ -1008,9 +1035,11 @@ private Thing GetOperationRootClone() private IEnumerable GetChainOfSubTransactions() { var parent = this.ParentTransaction; + while (parent != null) { yield return parent; + parent = parent.ParentTransaction; } } @@ -1027,6 +1056,7 @@ private IEnumerable GetChainOfSubTransactions() private void UpdateContainer(Thing clone, Thing containerclone, Thing nextThing = null) { var containerInformation = clone.GetContainerInformation(); + if (!containerInformation.Item1.IsInstanceOfType(containerclone)) { throw new InvalidOperationException("The containerClone does not have the right type"); @@ -1055,6 +1085,7 @@ private void UpdateContainer(Thing clone, Thing containerclone, Thing nextThing private void AddCloneToContainer(Thing clone, Thing containerclone, Thing nextThing = null) { var containerInformation = clone.GetContainerInformation(); + if (!containerInformation.Item1.IsInstanceOfType(containerclone)) { throw new InvalidOperationException("The containerClone does not have the right type"); @@ -1095,6 +1126,7 @@ public void Merge(IThingTransaction subTransaction) } var existingThing = this.AddedThing.SingleOrDefault(t => t.Iid == thing.Iid); + if (existingThing != null) { // replace the current thing with the one from the sub-transaction @@ -1112,6 +1144,7 @@ public void Merge(IThingTransaction subTransaction) if (this.UpdatedThing.ContainsKey(keyValuePair.Key)) { var parentKeyValue = this.UpdatedThing.Single(x => x.Key == keyValuePair.Key); + if (parentKeyValue.Value != keyValuePair.Value) { throw new InvalidOperationException("2 clones have been created for the same thing."); @@ -1122,6 +1155,7 @@ public void Merge(IThingTransaction subTransaction) // check if the key in a sub-transaction correspond to a value in the current one var existingKeyValue = this.UpdatedThing.SingleOrDefault(x => x.Value == keyValuePair.Key); + if (existingKeyValue.Key != null) { this.updatedThing[existingKeyValue.Key] = keyValuePair.Value; @@ -1249,7 +1283,7 @@ private void CreateCopyThingOperation(OperationContainer operationContainer) if (copyOperationKind.IsCopyOperation()) { operationContainer.AddOperation(new Operation(original, copy, copyOperationKind)); - } + } } } @@ -1273,7 +1307,8 @@ private int GetTopContainerRevisionNumber() things.AddRange(this.DeletedThing); things.AddRange(this.CopiedThing.Select(x => x.Key.Item2)); - var distinctTopContainer = things.Select(x => x.TopContainer).DistinctBy(t => t.Iid).ToList(); + var distinctTopContainer = things.Select(x => x.TopContainer).DistinctBy(t => t.Iid).ToList(); + if (distinctTopContainer.Count != 1) { throw new InvalidOperationException("multiple top container updates in one transaction, operation not allowed."); @@ -1290,18 +1325,21 @@ private void FilterOperationCausedByDelete() // filter out the added thing or updated thing that have been marked as deleted // filter out the contained thing of a deleted thing var markedForDeletion = this.DeletedThing.ToList(); + foreach (var thing in markedForDeletion) { var cloneType = thing.GetType(); + var containersInfo = cloneType.GetProperties().Where(x => - x.PropertyType.QueryIsGenericType() && - (x.PropertyType.GetGenericTypeDefinition() == typeof(ContainerList<>) || - x.PropertyType.GetGenericTypeDefinition() == typeof(OrderedItemList<>)) && - typeof(Thing).QueryIsAssignableFrom(x.PropertyType.GetGenericArguments().Single())).ToList(); + x.PropertyType.QueryIsGenericType() && + (x.PropertyType.GetGenericTypeDefinition() == typeof(ContainerList<>) || + x.PropertyType.GetGenericTypeDefinition() == typeof(OrderedItemList<>)) && + typeof(Thing).QueryIsAssignableFrom(x.PropertyType.GetGenericArguments().Single())).ToList(); foreach (var containerInfo in containersInfo) { var container = (IEnumerable)containerInfo.GetValue(thing); + foreach (Thing containedThing in container) { this.RemoveThingFromOperationLists(containedThing); @@ -1320,6 +1358,7 @@ private void RemoveThingFromOperationLists(Thing thingToRemove) { // remove it from the list of updated thing in the current transaction var updatedThingKey = this.UpdatedThing.Keys.SingleOrDefault(x => x.Iid == thingToRemove.Iid); + if (updatedThingKey != null) { this.updatedThing.Remove(updatedThingKey); @@ -1327,6 +1366,7 @@ private void RemoveThingFromOperationLists(Thing thingToRemove) // remove from the list of added thing var thingInAddedList = this.AddedThing.SingleOrDefault(x => x.Iid == thingToRemove.Iid); + if (thingInAddedList != null) { this.addedThing.Remove(thingInAddedList); @@ -1336,6 +1376,7 @@ private void RemoveThingFromOperationLists(Thing thingToRemove) if (!thingToRemove.IsCached()) { var thingInDeletedList = this.DeletedThing.SingleOrDefault(x => x.Iid == thingToRemove.Iid); + if (thingInDeletedList != null) { this.deletedThing.Remove(thingInDeletedList); @@ -1343,4 +1384,4 @@ private void RemoveThingFromOperationLists(Thing thingToRemove) } } } -} \ No newline at end of file +} diff --git a/CDP4Dal/Session.cs b/CDP4Dal/Session.cs index d7fec261..75024003 100644 --- a/CDP4Dal/Session.cs +++ b/CDP4Dal/Session.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4Dal { @@ -48,7 +48,8 @@ namespace CDP4Dal using CDP4Dal.Operations; using CDP4Dal.Permission; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Operations; + using CDP4DalCommon.Protocol.Tasks; using NLog; @@ -529,7 +530,7 @@ public async Task Read(ReferenceDataLibrary rdl) throw new InvalidOperationException("The ReferenceDataLibrary cannot be read when the ActivePerson is null; The Open method must be called prior to any of the Read methods"); } - await this.Read((Thing) rdl); + await this.Read((Thing)rdl); this.AddRdlToOpenList(rdl); } @@ -559,7 +560,7 @@ public async Task Read(IEnumerable engineeringModels) } logger.Info("Session.Read {EngineeringModel} {0}", !engineeringModels.Any() ? "*" : $"EngineeringModel/{engineeringModels.ToShortGuidArray()}"); - + // Create the token source var cancellationTokenSource = new CancellationTokenSource(); var cancellationTokenKey = Guid.NewGuid(); @@ -1265,7 +1266,7 @@ private IEnumerable GetSiteDirectoryAndActiveIterations() .Select(x => x.Value.Value) .Where(x => x is SiteDirectory - || x is Iteration && ((Iteration) x).IterationSetup.FrozenOn == null && this.OpenIterations.ContainsKey((Iteration) x) + || x is Iteration && ((Iteration)x).IterationSetup.FrozenOn == null && this.OpenIterations.ContainsKey((Iteration)x) ) .ToList(); } @@ -1332,7 +1333,7 @@ private void AddIterationToOpenList(Guid iterationId, DomainOfExpertise activeDo return; } - var activeParticipant = ((EngineeringModel) iteration.Container).EngineeringModelSetup.Participant.SingleOrDefault(p => p.Person == this.ActivePerson); + var activeParticipant = ((EngineeringModel)iteration.Container).EngineeringModelSetup.Participant.SingleOrDefault(p => p.Person == this.ActivePerson); if (activeParticipant == null) { @@ -1341,7 +1342,7 @@ private void AddIterationToOpenList(Guid iterationId, DomainOfExpertise activeDo this.openIterations.Add(iteration, new Tuple(activeDomain, activeParticipant)); - var modelRdl = ((EngineeringModel) iteration.Container).EngineeringModelSetup.RequiredRdl.Single(); + var modelRdl = ((EngineeringModel)iteration.Container).EngineeringModelSetup.RequiredRdl.Single(); this.AddRdlToOpenList(modelRdl); } diff --git a/CDP4Dal/Operations/Operation.cs b/CDP4DalCommon/Protocol/Operations/Operation.cs similarity index 75% rename from CDP4Dal/Operations/Operation.cs rename to CDP4DalCommon/Protocol/Operations/Operation.cs index 7adfa43f..8fe2e32f 100644 --- a/CDP4Dal/Operations/Operation.cs +++ b/CDP4DalCommon/Protocol/Operations/Operation.cs @@ -1,28 +1,28 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- -namespace CDP4Dal.Operations +namespace CDP4DalCommon.Protocol.Operations { using CDP4Common.DTO; diff --git a/CDP4Dal/Operations/OperationKind.cs b/CDP4DalCommon/Protocol/Operations/OperationKind.cs similarity index 80% rename from CDP4Dal/Operations/OperationKind.cs rename to CDP4DalCommon/Protocol/Operations/OperationKind.cs index 40150f47..db25f20c 100644 --- a/CDP4Dal/Operations/OperationKind.cs +++ b/CDP4DalCommon/Protocol/Operations/OperationKind.cs @@ -1,28 +1,28 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- -namespace CDP4Dal.Operations +namespace CDP4DalCommon.Protocol.Operations { using CDP4Common.DTO; @@ -87,4 +87,4 @@ public enum OperationKind /// CopyKeepValues } -} \ No newline at end of file +} diff --git a/CDP4Dal/Operations/PostOperation.cs b/CDP4DalCommon/Protocol/Operations/PostOperation.cs similarity index 76% rename from CDP4Dal/Operations/PostOperation.cs rename to CDP4DalCommon/Protocol/Operations/PostOperation.cs index 74acb4d1..8a526003 100644 --- a/CDP4Dal/Operations/PostOperation.cs +++ b/CDP4DalCommon/Protocol/Operations/PostOperation.cs @@ -1,30 +1,31 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- -namespace CDP4Dal.Operations +namespace CDP4DalCommon.Protocol.Operations { using System.Collections.Generic; + using CDP4Common; using CDP4Common.Dto; using CDP4Common.DTO; diff --git a/CDP4DalCommon/Tasks/CometTask.cs b/CDP4DalCommon/Protocol/Tasks/CometTask.cs similarity index 92% rename from CDP4DalCommon/Tasks/CometTask.cs rename to CDP4DalCommon/Protocol/Tasks/CometTask.cs index 9016cdee..f5615ed7 100644 --- a/CDP4DalCommon/Tasks/CometTask.cs +++ b/CDP4DalCommon/Protocol/Tasks/CometTask.cs @@ -2,7 +2,7 @@ // // Copyright (c) 2015-2024 Starion Group S.A. // -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -22,7 +22,7 @@ // // ------------------------------------------------------------------------------------------------------------------------------- -namespace CDP4DalCommon.Tasks +namespace CDP4DalCommon.Protocol.Tasks { using System; @@ -71,7 +71,7 @@ public CometTask() /// /// A value of -1 is returned when the task is still running or not completed with success /// - public readonly int Duration => this.ComputeDuration(); + public readonly int Duration => ComputeDuration(); /// /// Gets or sets the at which the was started @@ -107,12 +107,12 @@ public CometTask() /// The computated duration private readonly int ComputeDuration() { - if (!this.FinishedAt.HasValue || !this.StartedAt.HasValue) + if (!FinishedAt.HasValue || !StartedAt.HasValue) { return -1; } - var timeSpan = this.FinishedAt.Value - this.StartedAt.Value; + var timeSpan = FinishedAt.Value - StartedAt.Value; return (int)timeSpan.TotalSeconds; } } diff --git a/CDP4DalCommon/Tasks/StatusKind.cs b/CDP4DalCommon/Protocol/Tasks/StatusKind.cs similarity index 52% rename from CDP4DalCommon/Tasks/StatusKind.cs rename to CDP4DalCommon/Protocol/Tasks/StatusKind.cs index 639b6ff1..31bb5596 100644 --- a/CDP4DalCommon/Tasks/StatusKind.cs +++ b/CDP4DalCommon/Protocol/Tasks/StatusKind.cs @@ -1,29 +1,28 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. // -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // -// This file is part of CDP4-COMET Webservices Community Edition. -// The CDP4-COMET Web Services Community Edition is the Starion implementation of ECSS-E-TM-10-25 Annex A and Annex C. -// This is an auto-generated class. Any manual changes to this file will be overwritten! +// This file is part of CDP4-COMET SDK Community Edition // -// The CDP4-COMET Web Services Community Edition is free software; you can redistribute it and/or -// modify it under the terms of the GNU Affero General Public +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. // -// The CDP4-COMET Web Services Community Edition is distributed in the hope that it will be useful, +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // -// You should have received a copy of the GNU Affero General Public License -// along with this program. If not, see . +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- -namespace CDP4DalCommon.Tasks +namespace CDP4DalCommon.Protocol.Tasks { using System.Threading.Tasks; @@ -52,4 +51,4 @@ public enum StatusKind /// CANCELLED } -} \ No newline at end of file +} diff --git a/CDP4DalJsonSerializer/CDP4DalJsonSerializer.csproj b/CDP4DalJsonSerializer/CDP4DalJsonSerializer.csproj new file mode 100644 index 00000000..765eb528 --- /dev/null +++ b/CDP4DalJsonSerializer/CDP4DalJsonSerializer.csproj @@ -0,0 +1,44 @@ + + + + net47;net471;net472;net48;netstandard2.0;netstandard2.1 + RHEA System S.A. + latest + CDP4DalJsonSerializer Community Edition + 26.6.0 + JsonSerializer for the CDP4DalCommon types + Copyright © RHEA System S.A. + Sam, Alex, Alexander, Nathanael, Antoine, Omar, Jaime + CDP4DalJsonSerializer-CE + true + https://github.com/RHEAGROUP/COMET-SDK-Community-Edition + true + cdp4-icon.png + true + true + snupkg + https://github.com/RHEAGROUP/COMET-SDK-Community-Edition.git + CDP COMET ECSS-E-TM-10-25 + LGPL-3.0-only + + [BUMP] To CDP4Common 26.6.0 + + README.md + true + latest + + + + \ + true + + + \ + true + + + + + + + diff --git a/CDP4DalJsonSerializer/Cdp4DalJsonSerializer.cs b/CDP4DalJsonSerializer/Cdp4DalJsonSerializer.cs new file mode 100644 index 00000000..5b9e6f66 --- /dev/null +++ b/CDP4DalJsonSerializer/Cdp4DalJsonSerializer.cs @@ -0,0 +1,86 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +namespace CDP4DalJsonSerializer +{ + using System; + + using CDP4Common.MetaInfo; + + using CDP4DalCommon.Protocol.Operations; + + using CDP4DalJsonSerializer.JsonConverter; + + using CDP4JsonSerializer; + + /// + /// The is a that also supports (de)serialization of + /// + /// + public class Cdp4DalJsonSerializer : Cdp4JsonSerializer + { + /// + /// Asserts that the have to be ignored + /// + private readonly bool ignorePostOperationCopyProperty; + + /// + /// Initializes a new instance of the class. + /// + /// + /// The meta Info Provider. + /// + /// + /// The supported version of the data-model + /// + /// Asserts that the have to be ignored + public Cdp4DalJsonSerializer(IMetaDataProvider metaInfoProvider, Version supportedVersion, bool ignorePostOperationCopyProperty = false) + { + this.ignorePostOperationCopyProperty = ignorePostOperationCopyProperty; + + this.Initialize(metaInfoProvider, supportedVersion); + } + + /// + /// Initializes a new instance of the class. + /// + /// Asserts that the have to be ignored + public Cdp4DalJsonSerializer(bool ignorePostOperationCopyProperty = false) + { + this.ignorePostOperationCopyProperty = ignorePostOperationCopyProperty; + } + + /// + /// Initialize this instance with the required and supported + /// + /// The + /// The supported + public override void Initialize(IMetaDataProvider metaInfoProvider, Version supportedVersion) + { + base.Initialize(metaInfoProvider, supportedVersion); + + this.JsonSerializerOptions.Converters.Add(new PostOperationJsonConverter(this.ignorePostOperationCopyProperty)); + } + } +} diff --git a/CDP4DalJsonSerializer/Extensions/JsonElementExtensions.cs b/CDP4DalJsonSerializer/Extensions/JsonElementExtensions.cs new file mode 100644 index 00000000..1a7d927f --- /dev/null +++ b/CDP4DalJsonSerializer/Extensions/JsonElementExtensions.cs @@ -0,0 +1,70 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +namespace CDP4DalJsonSerializer.Extensions +{ + using System.Collections.Generic; + using System.Text.Json; + + using CDP4Common; + using CDP4Common.Dto; + using CDP4Common.DTO; + + using CDP4DalCommon.Protocol.Operations; + + /// + /// Extension class for + /// + public static class JsonElementExtensions + { + /// + /// Deserialize the content of the to the + /// + /// The + /// The that will receive new value properties + /// The + public static void DeserializePostOperation(this JsonElement element, PostOperation postOperation, JsonSerializerOptions serializerOptions) + { + if (element.TryGetProperty("_delete", out var deleteElement)) + { + postOperation.Delete = deleteElement.Deserialize>(serializerOptions); + } + + if (element.TryGetProperty("_create", out var createElement)) + { + postOperation.Create = createElement.Deserialize>(serializerOptions); + } + + if (element.TryGetProperty("_update", out var updateElement)) + { + postOperation.Update = updateElement.Deserialize>(serializerOptions); + } + + if (element.TryGetProperty("_copy", out var copyElement)) + { + postOperation.Copy = copyElement.Deserialize>(serializerOptions); + } + } + } +} diff --git a/CDP4DalJsonSerializer/JsonConverter/PostOperationJsonConverter.cs b/CDP4DalJsonSerializer/JsonConverter/PostOperationJsonConverter.cs new file mode 100644 index 00000000..90b70787 --- /dev/null +++ b/CDP4DalJsonSerializer/JsonConverter/PostOperationJsonConverter.cs @@ -0,0 +1,150 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +namespace CDP4DalJsonSerializer.JsonConverter +{ + using System; + using System.IO; + using System.Text.Json; + using System.Text.Json.Serialization; + + using CDP4Common.Polyfills; + + using CDP4DalCommon.Protocol.Operations; + + using CDP4DalJsonSerializer.Extensions; + + using NLog; + + /// + /// The for s + /// + public class PostOperationJsonConverter: JsonConverter + { + /// + /// The NLog logger + /// + private static readonly Logger Logger = LogManager.GetCurrentClassLogger(); + + /// + /// Asserts that the have to be ignored + /// + private readonly bool ignoreCopyProperty; + + /// + /// Initializes a new instance. + /// + /// Asserts that the have to be ignored + public PostOperationJsonConverter(bool ignoreCopyProperty = false) + { + this.ignoreCopyProperty = ignoreCopyProperty; + } + + /// + /// Override of the can convert type check. + /// + /// + /// The object type. + /// + /// + /// true if this converter is to be used. + /// + public override bool CanConvert(Type typeToConvert) + { + return typeof(PostOperation).QueryIsAssignableFrom(typeToConvert); + } + + /// Reads and converts the JSON to type . + /// The reader. + /// The type to convert. + /// An object that specifies serialization options to use. + /// The converted value. + public override PostOperation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + if (!JsonElement.TryParseValue(ref reader, out var jsonElement)) + { + Logger.Error("The data object in the JSON array could not be cast to a JsonElement type."); + throw new InvalidDataException("The data object in the JSON array could not be cast to a JObject type."); + } + + var initializedPostOperation = Activator.CreateInstance(typeToConvert); + + if (initializedPostOperation is not PostOperation postOperation) + { + Logger.Error($"The request Type {typeToConvert.Name} is not a PostOperation"); + throw new InvalidDataException($"The request Type {typeToConvert.Name} is not a PostOperation"); + } + + jsonElement?.DeserializePostOperation(postOperation, options); + return postOperation; + } + + /// Writes a specified value as JSON. + /// The writer to write to. + /// The value to convert to JSON. + /// An object that specifies serialization options to use. + public override void Write(Utf8JsonWriter writer, PostOperation value, JsonSerializerOptions options) + { + writer.WriteStartObject(); + writer.WriteStartArray("_delete"); + + foreach (var toDelete in value.Delete) + { + JsonSerializer.Serialize(writer, toDelete, options); + } + + writer.WriteEndArray(); + writer.WriteStartArray("_create"); + + foreach (var toCreate in value.Create) + { + JsonSerializer.Serialize(writer, toCreate, options); + } + + writer.WriteEndArray(); + writer.WriteStartArray("_update"); + + foreach (var toUpdate in value.Update) + { + JsonSerializer.Serialize(writer, toUpdate, options); + } + + writer.WriteEndArray(); + + if (!this.ignoreCopyProperty) + { + writer.WriteStartArray("_copy"); + + foreach (var toCopy in value.Copy) + { + JsonSerializer.Serialize(writer, toCopy, options); + } + + writer.WriteEndArray(); + } + + writer.WriteEndObject(); + } + } +} diff --git a/CDP4JsonFileDal.NetCore.Tests/JsonFileDalTestFixture.cs b/CDP4JsonFileDal.NetCore.Tests/JsonFileDalTestFixture.cs index 441ecee1..0f187ce1 100644 --- a/CDP4JsonFileDal.NetCore.Tests/JsonFileDalTestFixture.cs +++ b/CDP4JsonFileDal.NetCore.Tests/JsonFileDalTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonFileDal.NetCore.Tests { @@ -32,6 +32,7 @@ namespace CDP4JsonFileDal.NetCore.Tests using System.Threading; using System.Threading.Tasks; + using CDP4Common; using CDP4Common.CommonData; using CDP4Common.DTO; using CDP4Common.Types; @@ -41,7 +42,7 @@ namespace CDP4JsonFileDal.NetCore.Tests using CDP4Dal.Exceptions; using CDP4Dal.Operations; - using CDP4JsonFileDal; + using CDP4DalCommon.Protocol.Operations; using Moq; @@ -69,9 +70,6 @@ namespace CDP4JsonFileDal.NetCore.Tests using SampledFunctionParameterType = CDP4Common.SiteDirectoryData.SampledFunctionParameterType; using ElementDefinition = CDP4Common.EngineeringModelData.ElementDefinition; using Parameter = CDP4Common.EngineeringModelData.Parameter; - - using CDP4Common; - using OrganizationalParticipant = CDP4Common.SiteDirectoryData.OrganizationalParticipant; [TestFixture] @@ -530,7 +528,7 @@ public async Task VerifyWriteOfIncompatibleVersionFile() var domain = siteDirectory.Domain.First(); var model = new CDP4Common.EngineeringModelData.EngineeringModel(modelSetup.EngineeringModelIid, newSession.Assembler.Cache, newDal.Credentials.Uri) - { EngineeringModelSetup = modelSetup }; + { EngineeringModelSetup = modelSetup }; var iteration = new CDP4Common.EngineeringModelData.Iteration(this.iterationIid, newSession.Assembler.Cache, newDal.Credentials.Uri); @@ -590,7 +588,7 @@ public async Task VerifyWriteOfCompatibleVersionFile() var domain = siteDirectory.Domain.First(); var model = new CDP4Common.EngineeringModelData.EngineeringModel(modelSetup.EngineeringModelIid, newSession.Assembler.Cache, newDal.Credentials.Uri) - { EngineeringModelSetup = modelSetup }; + { EngineeringModelSetup = modelSetup }; var iteration = new CDP4Common.EngineeringModelData.Iteration(this.iterationIid, newSession.Assembler.Cache, newDal.Credentials.Uri); @@ -690,6 +688,7 @@ private void CreateBasicModel() iterationSetup.IterationIid = this.iterationIid; iterationSetupPoco.IterationIid = this.iterationIid; + // EngineeringModel this.model = new EngineeringModel(Guid.NewGuid(), this.cache, this.credentials.Uri); this.modelSetupId = Guid.NewGuid(); diff --git a/CDP4JsonFileDal.Tests/JsonFileDalTestFixture.cs b/CDP4JsonFileDal.Tests/JsonFileDalTestFixture.cs index c9e23a60..60ecbf3e 100644 --- a/CDP4JsonFileDal.Tests/JsonFileDalTestFixture.cs +++ b/CDP4JsonFileDal.Tests/JsonFileDalTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonFileDal.Tests { @@ -32,6 +32,7 @@ namespace CDP4JsonFileDal.Tests using System.Threading; using System.Threading.Tasks; + using CDP4Common; using CDP4Common.CommonData; using CDP4Common.DTO; using CDP4Common.Types; @@ -41,7 +42,7 @@ namespace CDP4JsonFileDal.Tests using CDP4Dal.Exceptions; using CDP4Dal.Operations; - using CDP4JsonFileDal; + using CDP4DalCommon.Protocol.Operations; using Moq; @@ -69,9 +70,6 @@ namespace CDP4JsonFileDal.Tests using SampledFunctionParameterType = CDP4Common.SiteDirectoryData.SampledFunctionParameterType; using ElementDefinition = CDP4Common.EngineeringModelData.ElementDefinition; using Parameter = CDP4Common.EngineeringModelData.Parameter; - - using CDP4Common; - using OrganizationalParticipant = CDP4Common.SiteDirectoryData.OrganizationalParticipant; [TestFixture] @@ -252,7 +250,7 @@ public async Task VerifyThatReadReturnsCorrectDTO() // General assertions for any kind of Thing we read Assert.That(readResult, Is.Not.Null); Assert.That(readResult.Count, Is.Not.EqualTo(1)); - + var iter1 = readResult.Single(d => d.ClassKind == ClassKind.Iteration); Assert.That(iter1.ClassKind, Is.EqualTo(iterObject.ClassKind)); Assert.That(iter1.Iid, Is.EqualTo(iterObject.Iid)); @@ -436,7 +434,7 @@ public void VerifyCtorWithVersionAndCopyright() Assert.That(this.dal.Serializer.RequestDataModelVersion.Major, Is.EqualTo(1)); Assert.That(this.dal.Serializer.RequestDataModelVersion.Minor, Is.EqualTo(0)); Assert.That(this.dal.Serializer.RequestDataModelVersion.Build, Is.EqualTo(0)); - + this.dal.UpdateExchangeFileHeader(new Person { ShortName = "admin" }); Assert.That(this.dal.FileHeader, Is.InstanceOf()); @@ -689,6 +687,7 @@ private void CreateBasicModel() iterationSetup.IterationIid = this.iterationIid; iterationSetupPoco.IterationIid = this.iterationIid; + // EngineeringModel this.model = new EngineeringModel(Guid.NewGuid(), this.cache, this.credentials.Uri); this.modelSetupId = Guid.NewGuid(); @@ -732,10 +731,10 @@ private void AddExtraThingsForExportFilteringTests() var elementDefinition2 = new ElementDefinition(Guid.NewGuid(), this.cache, this.credentials.Uri); elementDefinition2.ShortName = "ED2"; elementDefinition2.Owner = this.model.EngineeringModelSetup.ActiveDomain.First(); - + var elementDefinition3 = new ElementDefinition(Guid.NewGuid(), this.cache, this.credentials.Uri); elementDefinition3.ShortName = "ED3"; - + var elementDefinition4 = new ElementDefinition(Guid.NewGuid(), this.cache, this.credentials.Uri); elementDefinition4.ShortName = "ED4"; elementDefinition4.Owner = new DomainOfExpertise(Guid.NewGuid(), this.cache, this.credentials.Uri); //Not in file @@ -754,7 +753,7 @@ private void AddExtraThingsForExportFilteringTests() elementDefinition1.Parameter.Add(sampledFunctionParameter1); elementDefinition2.Parameter.Add(sampledFunctionParameter2); - + this.iterationPoco.Element.Add(elementDefinition1); this.iterationPoco.Element.Add(elementDefinition2); this.iterationPoco.Element.Add(elementDefinition3); @@ -770,7 +769,7 @@ private void AddExtraThingsForExportFilteringTests() parameterOverride.ValueSet.Add(new CDP4Common.EngineeringModelData.ParameterOverrideValueSet(Guid.NewGuid(), this.cache, this.credentials.Uri)); parameterOverride.ValueSet.First().ParameterValueSet = sampledFunctionParameter2.ValueSet.First(); elementUsage.ParameterOverride.Add(parameterOverride); - + elementDefinition1.ContainedElement.Add(elementUsage); var citation = new CDP4Common.CommonData.Citation(Guid.NewGuid(), this.cache, this.credentials.Uri); diff --git a/CDP4JsonFileDal/CDP4JsonFileDal.csproj b/CDP4JsonFileDal/CDP4JsonFileDal.csproj index d413c538..840a6ca8 100644 --- a/CDP4JsonFileDal/CDP4JsonFileDal.csproj +++ b/CDP4JsonFileDal/CDP4JsonFileDal.csproj @@ -37,6 +37,7 @@ + diff --git a/CDP4JsonFileDal/JsonFileDal.cs b/CDP4JsonFileDal/JsonFileDal.cs index 6780ecad..a61e60f2 100644 --- a/CDP4JsonFileDal/JsonFileDal.cs +++ b/CDP4JsonFileDal/JsonFileDal.cs @@ -1,21 +1,21 @@ // ------------------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexandervan Delft, Nathanael Smiechowski, Ahmed Abulwafa Ahmed -// -// This file is part of COMET-SDK Community Edition -// -// The CDP4-COMET-SDK Community Edition is free software; you can redistribute it and/or +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-COMET-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. @@ -45,7 +45,10 @@ namespace CDP4JsonFileDal using CDP4Dal.Exceptions; using CDP4Dal.Operations; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Operations; + using CDP4DalCommon.Protocol.Tasks; + + using CDP4DalJsonSerializer; using CDP4JsonFileDal.Json; @@ -122,7 +125,7 @@ public class JsonFileDal : Dal /// public JsonFileDal() { - this.Serializer = new Cdp4JsonSerializer(this.MetaDataProvider, this.DalVersion); + this.Serializer = new Cdp4DalJsonSerializer(this.MetaDataProvider, this.DalVersion); } /// @@ -141,7 +144,7 @@ public JsonFileDal(Version dalVersion) this.DalVersion = dalVersion; } - this.Serializer = new Cdp4JsonSerializer(this.MetaDataProvider, this.DalVersion); + this.Serializer = new Cdp4DalJsonSerializer(this.MetaDataProvider, this.DalVersion); } /// @@ -160,9 +163,9 @@ public void UpdateExchangeFileHeader(Person person, string headerCopyright = nul } /// - /// Gets the + /// Gets the /// - public Cdp4JsonSerializer Serializer { get; private set; } + public Cdp4DalJsonSerializer Serializer { get; private set; } /// /// Gets the value indicating whether this is read only diff --git a/CDP4JsonSerializer.NetCore.Tests/Helper/SerializerHelperTestFixture.cs b/CDP4JsonSerializer.NetCore.Tests/Helper/SerializerHelperTestFixture.cs index ab90ec5b..c0e6b491 100644 --- a/CDP4JsonSerializer.NetCore.Tests/Helper/SerializerHelperTestFixture.cs +++ b/CDP4JsonSerializer.NetCore.Tests/Helper/SerializerHelperTestFixture.cs @@ -1,32 +1,35 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// // This file is part of CDP4-COMET SDK Community Edition -// +// // The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// +// // The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer.Tests.Helper { using System; using System.Collections.Generic; + using System.IO; using System.Linq; + using System.Text.Json; + using System.Text.Json.Nodes; using CDP4Common.EngineeringModelData; using CDP4Common.MetaInfo; @@ -54,17 +57,23 @@ public void VerifyThatToJsonObjectOfOrderedItemReturnsJObject() object value = null; value = System.Convert.ChangeType(123, Nullable.GetUnderlyingType(propertyInfo.PropertyType)); propertyInfo.SetValue(orderedItem, value); + var stream = new MemoryStream(); + var utf8Writer = new Utf8JsonWriter(stream); + utf8Writer.WriteOrderedItem(orderedItem); + utf8Writer.Flush(); + stream.Position = 0; + var ut8Reader = new Utf8JsonReader(stream.ToArray()); - var jObject = SerializerHelper.ToJsonObject(orderedItem); - Assert.That(jObject.Properties().Count(), Is.EqualTo(3)); + var jObject = JsonObject.Create(JsonElement.ParseValue(ref ut8Reader)); + Assert.That(jObject.AsEnumerable().Count(), Is.EqualTo(3)); - var k = jObject.Property("k"); + jObject.TryGetPropertyValue("k", out var k); Assert.That(k, Is.Not.Null); - var v = jObject.Property("v"); + jObject.TryGetPropertyValue("v", out var v); Assert.That(v, Is.Not.Null); - var m = jObject.Property("m"); + jObject.TryGetPropertyValue("m", out var m); Assert.That(m, Is.Not.Null); } @@ -75,10 +84,11 @@ public void Verify_that_ParameterValueSet_is_serialized_and_deserialized() values.Add("this is a\nnewline"); values.Add("this is another\nnewline"); - var engineeringModel = new EngineeringModel {Iid = Guid.Parse("5643764e-f880-44bf-90ae-361f6661ceae")}; - var iteration = new Iteration {Iid = Guid.Parse("f744ae63-cf36-4cc4-8d76-e83edd44f6d2")}; - var elementDefinition = new ElementDefinition {Iid = Guid.Parse("f7f173ea-a742-42a5-81f1-59da2f470f16") }; - var parameter = new Parameter {Iid = Guid.Parse("607764de-7598-4be2-9a95-34669de273e3") }; + var engineeringModel = new EngineeringModel { Iid = Guid.Parse("5643764e-f880-44bf-90ae-361f6661ceae") }; + var iteration = new Iteration { Iid = Guid.Parse("f744ae63-cf36-4cc4-8d76-e83edd44f6d2") }; + var elementDefinition = new ElementDefinition { Iid = Guid.Parse("f7f173ea-a742-42a5-81f1-59da2f470f16") }; + var parameter = new Parameter { Iid = Guid.Parse("607764de-7598-4be2-9a95-34669de273e3") }; + var parameterValueSet = new ParameterValueSet { Iid = Guid.Parse("2366c662-b857-4313-85ea-51f9bf4588b1"), Manual = new ValueArray(values) @@ -171,7 +181,7 @@ the CEND sequence.If I need to use CEND I must escape one of the "; - private static readonly string[] TestStrings = + private static readonly string[] TestStrings = { "value with trailing spaces ", "value with trailing space ", diff --git a/CDP4JsonSerializer.NetCore.Tests/JsonSerializerTestFixture.cs b/CDP4JsonSerializer.NetCore.Tests/JsonSerializerTestFixture.cs index 81f841d5..1b0d3bbc 100644 --- a/CDP4JsonSerializer.NetCore.Tests/JsonSerializerTestFixture.cs +++ b/CDP4JsonSerializer.NetCore.Tests/JsonSerializerTestFixture.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// // This file is part of CDP4-COMET SDK Community Edition -// +// // The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// +// // The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer.Tests { @@ -41,8 +41,6 @@ namespace CDP4JsonSerializer.Tests using CDP4JsonSerializer.Tests.Helper; - using Newtonsoft.Json; - using NUnit.Framework; using Dto = CDP4Common.DTO; @@ -117,7 +115,7 @@ public void VerifyThatSerializeTimeCorrectly() using var reader = new StreamReader(memoryStream); var txt = reader.ReadToEnd(); - + Assert.That(txt, Does.Not.Contain("2222-02-02T22:22:22.222222")); Assert.That(txt, Does.Contain("2222-02-02T22:22:22.222Z")); } @@ -407,7 +405,7 @@ public void VerifyThatSerializationofOperationsWorks() result.Update.Single(x => x["Iid"].ToString() == subscriptionValueset.Iid.ToString()); var valueArray = (ValueArray)subscriptionValueSetClasslessDto["Manual"]; - + Assert.That(subscriptionValueSetClasslessDto["Iid"] is Guid, Is.True); Assert.That(subscriptionValueSetClasslessDto["ClassKind"] is ClassKind, Is.True); @@ -457,7 +455,7 @@ public void VerifyThatSerializeGiveSameInput() using var reader = new StreamReader(stream); var serializerResult = reader.ReadToEnd().Replace("\r", string.Empty).Replace("\n", string.Empty).Replace("\t", string.Empty).Replace(" ", string.Empty).Trim(); - + Assert.That(response.Length, Is.EqualTo(serializerResult.Length)); } } @@ -498,7 +496,7 @@ public void VerifyThatValueSetDeserializationIsCorrectForStringThatRepresentEsca using var reader = new StreamReader(stream); var serializerResult = reader.ReadToEnd().Replace("\r", string.Empty).Replace("\n", string.Empty).Replace("\t", string.Empty).Replace(" ", string.Empty).Trim(); - + Assert.That(serializedParameterValueSet.Length, Is.EqualTo(serializerResult.Length)); } } @@ -611,19 +609,16 @@ private class TestPostOperation /// /// Gets or sets the collection of DTOs to delete. /// - [JsonProperty("_delete")] public List Delete { get; set; } /// /// Gets or sets the collection of DTOs to create. /// - [JsonProperty("_create")] public List Create { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_update")] public List Update { get; set; } /// diff --git a/CDP4JsonSerializer.Tests/Helper/SerializerHelperTestFixture.cs b/CDP4JsonSerializer.Tests/Helper/SerializerHelperTestFixture.cs index bd785bdd..3ea93b21 100644 --- a/CDP4JsonSerializer.Tests/Helper/SerializerHelperTestFixture.cs +++ b/CDP4JsonSerializer.Tests/Helper/SerializerHelperTestFixture.cs @@ -1,33 +1,36 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// // This file is part of CDP4-COMET SDK Community Edition -// +// // The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// +// // The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer.Tests.Helper { using System; using System.Collections.Generic; + using System.IO; using System.Linq; - + using System.Text.Json; + using System.Text.Json.Nodes; + using CDP4Common.EngineeringModelData; using CDP4Common.MetaInfo; using CDP4Common.Types; @@ -45,23 +48,30 @@ public void VerifyThatToJsonObjectOfOrderedItemReturnsJObject() { var uniqueIdentifier = Guid.NewGuid(); - var orderedItem = new OrderedItem {K = 1, V = uniqueIdentifier}; + var orderedItem = new OrderedItem { K = 1, V = uniqueIdentifier }; var propertyInfo = orderedItem.GetType().GetProperty("M"); - var value = System.Convert.ChangeType(123, Nullable.GetUnderlyingType(propertyInfo.PropertyType)); + object value = null; + value = System.Convert.ChangeType(123, Nullable.GetUnderlyingType(propertyInfo.PropertyType)); propertyInfo.SetValue(orderedItem, value); + var stream = new MemoryStream(); + var utf8Writer = new Utf8JsonWriter(stream); + utf8Writer.WriteOrderedItem(orderedItem); + utf8Writer.Flush(); + stream.Position = 0; + var ut8Reader = new Utf8JsonReader(stream.ToArray()); - var jObject = orderedItem.ToJsonObject(); - Assert.That(jObject.Properties().Count(), Is.EqualTo(3)); + var jObject = JsonObject.Create(JsonElement.ParseValue(ref ut8Reader)); + Assert.That(jObject.AsEnumerable().Count(), Is.EqualTo(3)); - var k = jObject.Property("k"); + jObject.TryGetPropertyValue("k", out var k); Assert.That(k, Is.Not.Null); - var v = jObject.Property("v"); + jObject.TryGetPropertyValue("v", out var v); Assert.That(v, Is.Not.Null); - var m = jObject.Property("m"); + jObject.TryGetPropertyValue("m", out var m); Assert.That(m, Is.Not.Null); } @@ -113,7 +123,7 @@ public void Verify_that_a_ValueArray_is_serialized_and_deserialized([ValueSource Assert.That(resultjson, Is.EqualTo(json), $"Json creation failed for string \"{input}\"."); } - + private const string JsonString = @"{""widget"": { ""debug"": ""on"", ""window"": { @@ -170,7 +180,7 @@ the CEND sequence.If I need to use CEND I must escape one of the "; - private static readonly string[] TestStrings = + private static readonly string[] TestStrings = { "value with trailing spaces ", "value with trailing space ", @@ -212,4 +222,4 @@ the CEND sequence.If I need to use CEND I must escape one of the JsonString }; } -} \ No newline at end of file +} diff --git a/CDP4JsonSerializer.Tests/JsonSerializerTestFixture.cs b/CDP4JsonSerializer.Tests/JsonSerializerTestFixture.cs index 146a7036..e200e6c3 100644 --- a/CDP4JsonSerializer.Tests/JsonSerializerTestFixture.cs +++ b/CDP4JsonSerializer.Tests/JsonSerializerTestFixture.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2021 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// // This file is part of CDP4-COMET SDK Community Edition -// +// // The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// +// // The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer.Tests { @@ -30,6 +30,7 @@ namespace CDP4JsonSerializer.Tests using System.Diagnostics; using System.IO; using System.Linq; + using System.Text.Json.Serialization; using CDP4Common; using CDP4Common.CommonData; @@ -41,8 +42,6 @@ namespace CDP4JsonSerializer.Tests using CDP4JsonSerializer.Tests.Helper; - using Newtonsoft.Json; - using NUnit.Framework; using Dto = CDP4Common.DTO; @@ -170,7 +169,7 @@ public void VerifyThatValueArrayAreSerializedCorrectly() var txt = reader.ReadToEnd(); // output: "manual":"[\"123\",\"abc\"]" - Assert.That(txt, Does.Contain("\"manual\":\"[\\\"123\\\",\\\"abc\\\"]\"")); + Assert.That(txt, Does.Contain("\"manual\":\"[\\\"123\\\",\\\"abc\\\"]\"")); } } } @@ -412,9 +411,10 @@ public void VerifyThatSerializationofOperationsWorks() // necessary memoryStream.Position = 0; - + var content = new StreamReader(memoryStream).ReadToEnd(); + memoryStream.Position = 0; var result = this.serializer.Deserialize(memoryStream); - + Assert.That(result.Delete.Count, Is.EqualTo(1)); Assert.That(result.Create.Count, Is.EqualTo(1)); Assert.That(result.Update.Count, Is.EqualTo(2)); @@ -617,19 +617,19 @@ private class TestPostOperation /// /// Gets or sets the collection of DTOs to delete. /// - [JsonProperty("_delete")] + [JsonPropertyName("_delete")] public List Delete { get; set; } /// /// Gets or sets the collection of DTOs to create. /// - [JsonProperty("_create")] + [JsonPropertyName("_create")] public List Create { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_update")] + [JsonPropertyName("_update")] public List Update { get; set; } /// diff --git a/CDP4JsonSerializer.Tests/PostOperation/CdpPostOperation.cs b/CDP4JsonSerializer.Tests/PostOperation/CdpPostOperation.cs index 607c8e50..ed7bacaa 100644 --- a/CDP4JsonSerializer.Tests/PostOperation/CdpPostOperation.cs +++ b/CDP4JsonSerializer.Tests/PostOperation/CdpPostOperation.cs @@ -1,51 +1,50 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// // This file is part of CDP4-COMET SDK Community Edition -// +// // The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// +// // The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer.Tests.Cdp4PostOperation { using System.Collections.Generic; + using System.Text.Json.Serialization; using CDP4Common; using CDP4Common.DTO; - using Newtonsoft.Json; - /// /// A CdpPostOperation class used for testing purposes /// public class CdpPostOperation { - [JsonProperty("_delete")] + [JsonPropertyName("_delete")] public List Delete { get; set; } - [JsonProperty("_create")] + [JsonPropertyName("_create")] public List Create { get; set; } - [JsonProperty("_update")] + [JsonPropertyName("_update")] public List Update { get; set; } - [JsonProperty("_copy")] + [JsonPropertyName("_copy")] public List Copy { get; set; } } -} \ No newline at end of file +} diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ActionItemResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ActionItemResolver.cs index c4c630f6..7e7c2b21 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ActionItemResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ActionItemResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(actioneeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale actionee property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale actionee property of the actionItem {id} is null", actionItem.Iid); } else { @@ -87,7 +87,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale author property of the actionItem {id} is null", actionItem.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(classificationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale classification property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale classification property of the actionItem {id} is null", actionItem.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(closeOutStatementProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale closeOutStatement property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale closeOutStatement property of the actionItem {id} is null", actionItem.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale content property of the actionItem {id} is null", actionItem.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale createdOn property of the actionItem {id} is null", actionItem.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(dueDateProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale dueDate property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale dueDate property of the actionItem {id} is null", actionItem.Iid); } else { @@ -203,7 +203,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale languageCode property of the actionItem {id} is null", actionItem.Iid); } else { @@ -215,7 +215,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the actionItem {id} is null", actionItem.Iid); } else { @@ -227,7 +227,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale owner property of the actionItem {id} is null", actionItem.Iid); } else { @@ -259,7 +259,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale shortName property of the actionItem {id} is null", actionItem.Iid); } else { @@ -279,7 +279,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(statusProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale status property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale status property of the actionItem {id} is null", actionItem.Iid); } else { @@ -291,7 +291,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale thingPreference property of the actionItem {id} is null", actionItem.Iid); } else { @@ -303,7 +303,7 @@ public static CDP4Common.DTO.ActionItem FromJsonObject(JsonElement jsonElement) { if(titleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale title property of the actionItem {id} is null", actionItem.Iid); + Logger.Debug("The non-nullabale title property of the actionItem {id} is null", actionItem.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ActualFiniteStateListResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ActualFiniteStateListResolver.cs index 5f599126..9ff4be99 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ActualFiniteStateListResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ActualFiniteStateListResolver.cs @@ -99,7 +99,7 @@ public static CDP4Common.DTO.ActualFiniteStateList FromJsonObject(JsonElement js { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the actualFiniteStateList {id} is null", actualFiniteStateList.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the actualFiniteStateList {id} is null", actualFiniteStateList.Iid); } else { @@ -111,7 +111,7 @@ public static CDP4Common.DTO.ActualFiniteStateList FromJsonObject(JsonElement js { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the actualFiniteStateList {id} is null", actualFiniteStateList.Iid); + Logger.Debug("The non-nullabale owner property of the actualFiniteStateList {id} is null", actualFiniteStateList.Iid); } else { @@ -128,7 +128,7 @@ public static CDP4Common.DTO.ActualFiniteStateList FromJsonObject(JsonElement js { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the actualFiniteStateList {id} is null", actualFiniteStateList.Iid); + Logger.Debug("The non-nullabale thingPreference property of the actualFiniteStateList {id} is null", actualFiniteStateList.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ActualFiniteStateResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ActualFiniteStateResolver.cs index 97474b0d..15268683 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ActualFiniteStateResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ActualFiniteStateResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.ActualFiniteState FromJsonObject(JsonElement jsonEl { if(kindProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale kind property of the actualFiniteState {id} is null", actualFiniteState.Iid); + Logger.Debug("The non-nullabale kind property of the actualFiniteState {id} is null", actualFiniteState.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ActualFiniteState FromJsonObject(JsonElement jsonEl { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the actualFiniteState {id} is null", actualFiniteState.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the actualFiniteState {id} is null", actualFiniteState.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.ActualFiniteState FromJsonObject(JsonElement jsonEl { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the actualFiniteState {id} is null", actualFiniteState.Iid); + Logger.Debug("The non-nullabale thingPreference property of the actualFiniteState {id} is null", actualFiniteState.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/AliasResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/AliasResolver.cs index bb0f859c..56a4aacf 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/AliasResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/AliasResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.Alias FromJsonObject(JsonElement jsonElement) { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the alias {id} is null", alias.Iid); + Logger.Debug("The non-nullabale content property of the alias {id} is null", alias.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.Alias FromJsonObject(JsonElement jsonElement) { if(isSynonymProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isSynonym property of the alias {id} is null", alias.Iid); + Logger.Debug("The non-nullabale isSynonym property of the alias {id} is null", alias.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.Alias FromJsonObject(JsonElement jsonElement) { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the alias {id} is null", alias.Iid); + Logger.Debug("The non-nullabale languageCode property of the alias {id} is null", alias.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.Alias FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the alias {id} is null", alias.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the alias {id} is null", alias.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Alias FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the alias {id} is null", alias.Iid); + Logger.Debug("The non-nullabale thingPreference property of the alias {id} is null", alias.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/AndExpressionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/AndExpressionResolver.cs index 51a6c741..1ea4589f 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/AndExpressionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/AndExpressionResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.AndExpression FromJsonObject(JsonElement jsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the andExpression {id} is null", andExpression.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the andExpression {id} is null", andExpression.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.AndExpression FromJsonObject(JsonElement jsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the andExpression {id} is null", andExpression.Iid); + Logger.Debug("The non-nullabale thingPreference property of the andExpression {id} is null", andExpression.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ApprovalResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ApprovalResolver.cs index 1a8acf81..a7223295 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ApprovalResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ApprovalResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.Approval FromJsonObject(JsonElement jsonElement) { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the approval {id} is null", approval.Iid); + Logger.Debug("The non-nullabale author property of the approval {id} is null", approval.Iid); } else { @@ -79,7 +79,7 @@ public static CDP4Common.DTO.Approval FromJsonObject(JsonElement jsonElement) { if(classificationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale classification property of the approval {id} is null", approval.Iid); + Logger.Debug("The non-nullabale classification property of the approval {id} is null", approval.Iid); } else { @@ -91,7 +91,7 @@ public static CDP4Common.DTO.Approval FromJsonObject(JsonElement jsonElement) { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the approval {id} is null", approval.Iid); + Logger.Debug("The non-nullabale content property of the approval {id} is null", approval.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.Approval FromJsonObject(JsonElement jsonElement) { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the approval {id} is null", approval.Iid); + Logger.Debug("The non-nullabale createdOn property of the approval {id} is null", approval.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Approval FromJsonObject(JsonElement jsonElement) { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the approval {id} is null", approval.Iid); + Logger.Debug("The non-nullabale languageCode property of the approval {id} is null", approval.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.Approval FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the approval {id} is null", approval.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the approval {id} is null", approval.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.Approval FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the approval {id} is null", approval.Iid); + Logger.Debug("The non-nullabale owner property of the approval {id} is null", approval.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.Approval FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the approval {id} is null", approval.Iid); + Logger.Debug("The non-nullabale thingPreference property of the approval {id} is null", approval.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ArrayParameterTypeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ArrayParameterTypeResolver.cs index 7468710c..c159b1b5 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ArrayParameterTypeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ArrayParameterTypeResolver.cs @@ -125,7 +125,7 @@ public static CDP4Common.DTO.ArrayParameterType FromJsonObject(JsonElement jsonE { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the arrayParameterType {id} is null", arrayParameterType.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the arrayParameterType {id} is null", arrayParameterType.Iid); } else { @@ -137,7 +137,7 @@ public static CDP4Common.DTO.ArrayParameterType FromJsonObject(JsonElement jsonE { if(isFinalizedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isFinalized property of the arrayParameterType {id} is null", arrayParameterType.Iid); + Logger.Debug("The non-nullabale isFinalized property of the arrayParameterType {id} is null", arrayParameterType.Iid); } else { @@ -149,7 +149,7 @@ public static CDP4Common.DTO.ArrayParameterType FromJsonObject(JsonElement jsonE { if(isTensorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isTensor property of the arrayParameterType {id} is null", arrayParameterType.Iid); + Logger.Debug("The non-nullabale isTensor property of the arrayParameterType {id} is null", arrayParameterType.Iid); } else { @@ -161,7 +161,7 @@ public static CDP4Common.DTO.ArrayParameterType FromJsonObject(JsonElement jsonE { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the arrayParameterType {id} is null", arrayParameterType.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the arrayParameterType {id} is null", arrayParameterType.Iid); } else { @@ -173,7 +173,7 @@ public static CDP4Common.DTO.ArrayParameterType FromJsonObject(JsonElement jsonE { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the arrayParameterType {id} is null", arrayParameterType.Iid); + Logger.Debug("The non-nullabale name property of the arrayParameterType {id} is null", arrayParameterType.Iid); } else { @@ -185,7 +185,7 @@ public static CDP4Common.DTO.ArrayParameterType FromJsonObject(JsonElement jsonE { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the arrayParameterType {id} is null", arrayParameterType.Iid); + Logger.Debug("The non-nullabale shortName property of the arrayParameterType {id} is null", arrayParameterType.Iid); } else { @@ -197,7 +197,7 @@ public static CDP4Common.DTO.ArrayParameterType FromJsonObject(JsonElement jsonE { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the arrayParameterType {id} is null", arrayParameterType.Iid); + Logger.Debug("The non-nullabale symbol property of the arrayParameterType {id} is null", arrayParameterType.Iid); } else { @@ -209,7 +209,7 @@ public static CDP4Common.DTO.ArrayParameterType FromJsonObject(JsonElement jsonE { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the arrayParameterType {id} is null", arrayParameterType.Iid); + Logger.Debug("The non-nullabale thingPreference property of the arrayParameterType {id} is null", arrayParameterType.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryNoteResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryNoteResolver.cs index 84fd7954..0e4aa3f3 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryNoteResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryNoteResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.BinaryNote FromJsonObject(JsonElement jsonElement) { if(captionProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale caption property of the binaryNote {id} is null", binaryNote.Iid); + Logger.Debug("The non-nullabale caption property of the binaryNote {id} is null", binaryNote.Iid); } else { @@ -87,7 +87,7 @@ public static CDP4Common.DTO.BinaryNote FromJsonObject(JsonElement jsonElement) { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the binaryNote {id} is null", binaryNote.Iid); + Logger.Debug("The non-nullabale createdOn property of the binaryNote {id} is null", binaryNote.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.BinaryNote FromJsonObject(JsonElement jsonElement) { if(fileTypeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale fileType property of the binaryNote {id} is null", binaryNote.Iid); + Logger.Debug("The non-nullabale fileType property of the binaryNote {id} is null", binaryNote.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.BinaryNote FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the binaryNote {id} is null", binaryNote.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the binaryNote {id} is null", binaryNote.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.BinaryNote FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the binaryNote {id} is null", binaryNote.Iid); + Logger.Debug("The non-nullabale name property of the binaryNote {id} is null", binaryNote.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.BinaryNote FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the binaryNote {id} is null", binaryNote.Iid); + Logger.Debug("The non-nullabale owner property of the binaryNote {id} is null", binaryNote.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.BinaryNote FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the binaryNote {id} is null", binaryNote.Iid); + Logger.Debug("The non-nullabale shortName property of the binaryNote {id} is null", binaryNote.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.BinaryNote FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the binaryNote {id} is null", binaryNote.Iid); + Logger.Debug("The non-nullabale thingPreference property of the binaryNote {id} is null", binaryNote.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryRelationshipResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryRelationshipResolver.cs index b324a7a2..2f4ce317 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryRelationshipResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryRelationshipResolver.cs @@ -91,7 +91,7 @@ public static CDP4Common.DTO.BinaryRelationship FromJsonObject(JsonElement jsonE { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the binaryRelationship {id} is null", binaryRelationship.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the binaryRelationship {id} is null", binaryRelationship.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.BinaryRelationship FromJsonObject(JsonElement jsonE { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the binaryRelationship {id} is null", binaryRelationship.Iid); + Logger.Debug("The non-nullabale name property of the binaryRelationship {id} is null", binaryRelationship.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.BinaryRelationship FromJsonObject(JsonElement jsonE { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the binaryRelationship {id} is null", binaryRelationship.Iid); + Logger.Debug("The non-nullabale owner property of the binaryRelationship {id} is null", binaryRelationship.Iid); } else { @@ -135,7 +135,7 @@ public static CDP4Common.DTO.BinaryRelationship FromJsonObject(JsonElement jsonE { if(sourceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale source property of the binaryRelationship {id} is null", binaryRelationship.Iid); + Logger.Debug("The non-nullabale source property of the binaryRelationship {id} is null", binaryRelationship.Iid); } else { @@ -147,7 +147,7 @@ public static CDP4Common.DTO.BinaryRelationship FromJsonObject(JsonElement jsonE { if(targetProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale target property of the binaryRelationship {id} is null", binaryRelationship.Iid); + Logger.Debug("The non-nullabale target property of the binaryRelationship {id} is null", binaryRelationship.Iid); } else { @@ -159,7 +159,7 @@ public static CDP4Common.DTO.BinaryRelationship FromJsonObject(JsonElement jsonE { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the binaryRelationship {id} is null", binaryRelationship.Iid); + Logger.Debug("The non-nullabale thingPreference property of the binaryRelationship {id} is null", binaryRelationship.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryRelationshipRuleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryRelationshipRuleResolver.cs index ee15b3b0..d27b9cbf 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryRelationshipRuleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/BinaryRelationshipRuleResolver.cs @@ -99,7 +99,7 @@ public static CDP4Common.DTO.BinaryRelationshipRule FromJsonObject(JsonElement j { if(forwardRelationshipNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale forwardRelationshipName property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); + Logger.Debug("The non-nullabale forwardRelationshipName property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.BinaryRelationshipRule FromJsonObject(JsonElement j { if(inverseRelationshipNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale inverseRelationshipName property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); + Logger.Debug("The non-nullabale inverseRelationshipName property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.BinaryRelationshipRule FromJsonObject(JsonElement j { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.BinaryRelationshipRule FromJsonObject(JsonElement j { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.BinaryRelationshipRule FromJsonObject(JsonElement j { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); + Logger.Debug("The non-nullabale name property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.BinaryRelationshipRule FromJsonObject(JsonElement j { if(relationshipCategoryProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale relationshipCategory property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); + Logger.Debug("The non-nullabale relationshipCategory property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); } else { @@ -179,7 +179,7 @@ public static CDP4Common.DTO.BinaryRelationshipRule FromJsonObject(JsonElement j { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); + Logger.Debug("The non-nullabale shortName property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); } else { @@ -191,7 +191,7 @@ public static CDP4Common.DTO.BinaryRelationshipRule FromJsonObject(JsonElement j { if(sourceCategoryProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale sourceCategory property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); + Logger.Debug("The non-nullabale sourceCategory property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); } else { @@ -203,7 +203,7 @@ public static CDP4Common.DTO.BinaryRelationshipRule FromJsonObject(JsonElement j { if(targetCategoryProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale targetCategory property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); + Logger.Debug("The non-nullabale targetCategory property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); } else { @@ -215,7 +215,7 @@ public static CDP4Common.DTO.BinaryRelationshipRule FromJsonObject(JsonElement j { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); + Logger.Debug("The non-nullabale thingPreference property of the binaryRelationshipRule {id} is null", binaryRelationshipRule.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/BookResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/BookResolver.cs index ec7c73f5..02a84983 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/BookResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/BookResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.Book FromJsonObject(JsonElement jsonElement) { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the book {id} is null", book.Iid); + Logger.Debug("The non-nullabale createdOn property of the book {id} is null", book.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.Book FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the book {id} is null", book.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the book {id} is null", book.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.Book FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the book {id} is null", book.Iid); + Logger.Debug("The non-nullabale name property of the book {id} is null", book.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.Book FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the book {id} is null", book.Iid); + Logger.Debug("The non-nullabale owner property of the book {id} is null", book.Iid); } else { @@ -144,7 +144,7 @@ public static CDP4Common.DTO.Book FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the book {id} is null", book.Iid); + Logger.Debug("The non-nullabale shortName property of the book {id} is null", book.Iid); } else { @@ -156,7 +156,7 @@ public static CDP4Common.DTO.Book FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the book {id} is null", book.Iid); + Logger.Debug("The non-nullabale thingPreference property of the book {id} is null", book.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/BooleanParameterTypeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/BooleanParameterTypeResolver.cs index 3adccd1f..78a4acd3 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/BooleanParameterTypeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/BooleanParameterTypeResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.BooleanParameterType FromJsonObject(JsonElement jso { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the booleanParameterType {id} is null", booleanParameterType.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the booleanParameterType {id} is null", booleanParameterType.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.BooleanParameterType FromJsonObject(JsonElement jso { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the booleanParameterType {id} is null", booleanParameterType.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the booleanParameterType {id} is null", booleanParameterType.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.BooleanParameterType FromJsonObject(JsonElement jso { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the booleanParameterType {id} is null", booleanParameterType.Iid); + Logger.Debug("The non-nullabale name property of the booleanParameterType {id} is null", booleanParameterType.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.BooleanParameterType FromJsonObject(JsonElement jso { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the booleanParameterType {id} is null", booleanParameterType.Iid); + Logger.Debug("The non-nullabale shortName property of the booleanParameterType {id} is null", booleanParameterType.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.BooleanParameterType FromJsonObject(JsonElement jso { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the booleanParameterType {id} is null", booleanParameterType.Iid); + Logger.Debug("The non-nullabale symbol property of the booleanParameterType {id} is null", booleanParameterType.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.BooleanParameterType FromJsonObject(JsonElement jso { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the booleanParameterType {id} is null", booleanParameterType.Iid); + Logger.Debug("The non-nullabale thingPreference property of the booleanParameterType {id} is null", booleanParameterType.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/BoundsResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/BoundsResolver.cs index 2ab0b509..040a11bd 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/BoundsResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/BoundsResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.Bounds FromJsonObject(JsonElement jsonElement) { if(heightProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale height property of the bounds {id} is null", bounds.Iid); + Logger.Debug("The non-nullabale height property of the bounds {id} is null", bounds.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.Bounds FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the bounds {id} is null", bounds.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the bounds {id} is null", bounds.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.Bounds FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the bounds {id} is null", bounds.Iid); + Logger.Debug("The non-nullabale name property of the bounds {id} is null", bounds.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.Bounds FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the bounds {id} is null", bounds.Iid); + Logger.Debug("The non-nullabale thingPreference property of the bounds {id} is null", bounds.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Bounds FromJsonObject(JsonElement jsonElement) { if(widthProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale width property of the bounds {id} is null", bounds.Iid); + Logger.Debug("The non-nullabale width property of the bounds {id} is null", bounds.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.Bounds FromJsonObject(JsonElement jsonElement) { if(xProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale x property of the bounds {id} is null", bounds.Iid); + Logger.Debug("The non-nullabale x property of the bounds {id} is null", bounds.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.Bounds FromJsonObject(JsonElement jsonElement) { if(yProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale y property of the bounds {id} is null", bounds.Iid); + Logger.Debug("The non-nullabale y property of the bounds {id} is null", bounds.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/BuiltInRuleVerificationResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/BuiltInRuleVerificationResolver.cs index 98ff206d..e8689128 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/BuiltInRuleVerificationResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/BuiltInRuleVerificationResolver.cs @@ -95,7 +95,7 @@ public static CDP4Common.DTO.BuiltInRuleVerification FromJsonObject(JsonElement { if(isActiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isActive property of the builtInRuleVerification {id} is null", builtInRuleVerification.Iid); + Logger.Debug("The non-nullabale isActive property of the builtInRuleVerification {id} is null", builtInRuleVerification.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.BuiltInRuleVerification FromJsonObject(JsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the builtInRuleVerification {id} is null", builtInRuleVerification.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the builtInRuleVerification {id} is null", builtInRuleVerification.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.BuiltInRuleVerification FromJsonObject(JsonElement { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the builtInRuleVerification {id} is null", builtInRuleVerification.Iid); + Logger.Debug("The non-nullabale name property of the builtInRuleVerification {id} is null", builtInRuleVerification.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.BuiltInRuleVerification FromJsonObject(JsonElement { if(statusProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale status property of the builtInRuleVerification {id} is null", builtInRuleVerification.Iid); + Logger.Debug("The non-nullabale status property of the builtInRuleVerification {id} is null", builtInRuleVerification.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.BuiltInRuleVerification FromJsonObject(JsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the builtInRuleVerification {id} is null", builtInRuleVerification.Iid); + Logger.Debug("The non-nullabale thingPreference property of the builtInRuleVerification {id} is null", builtInRuleVerification.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/CategoryResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/CategoryResolver.cs index 13630246..babc936a 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/CategoryResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/CategoryResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.Category FromJsonObject(JsonElement jsonElement) { if(isAbstractProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isAbstract property of the category {id} is null", category.Iid); + Logger.Debug("The non-nullabale isAbstract property of the category {id} is null", category.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.Category FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the category {id} is null", category.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the category {id} is null", category.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Category FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the category {id} is null", category.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the category {id} is null", category.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.Category FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the category {id} is null", category.Iid); + Logger.Debug("The non-nullabale name property of the category {id} is null", category.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.Category FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the category {id} is null", category.Iid); + Logger.Debug("The non-nullabale shortName property of the category {id} is null", category.Iid); } else { @@ -183,7 +183,7 @@ public static CDP4Common.DTO.Category FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the category {id} is null", category.Iid); + Logger.Debug("The non-nullabale thingPreference property of the category {id} is null", category.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ChangeProposalResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ChangeProposalResolver.cs index d7fd3c3d..fae894ee 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ChangeProposalResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ChangeProposalResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale author property of the changeProposal {id} is null", changeProposal.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(changeRequestProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale changeRequest property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale changeRequest property of the changeProposal {id} is null", changeProposal.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(classificationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale classification property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale classification property of the changeProposal {id} is null", changeProposal.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale content property of the changeProposal {id} is null", changeProposal.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale createdOn property of the changeProposal {id} is null", changeProposal.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale languageCode property of the changeProposal {id} is null", changeProposal.Iid); } else { @@ -179,7 +179,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the changeProposal {id} is null", changeProposal.Iid); } else { @@ -191,7 +191,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale owner property of the changeProposal {id} is null", changeProposal.Iid); } else { @@ -223,7 +223,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale shortName property of the changeProposal {id} is null", changeProposal.Iid); } else { @@ -243,7 +243,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(statusProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale status property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale status property of the changeProposal {id} is null", changeProposal.Iid); } else { @@ -255,7 +255,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale thingPreference property of the changeProposal {id} is null", changeProposal.Iid); } else { @@ -267,7 +267,7 @@ public static CDP4Common.DTO.ChangeProposal FromJsonObject(JsonElement jsonEleme { if(titleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale title property of the changeProposal {id} is null", changeProposal.Iid); + Logger.Debug("The non-nullabale title property of the changeProposal {id} is null", changeProposal.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ChangeRequestResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ChangeRequestResolver.cs index 65ee3515..e7cd93b1 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ChangeRequestResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ChangeRequestResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.ChangeRequest FromJsonObject(JsonElement jsonElemen { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the changeRequest {id} is null", changeRequest.Iid); + Logger.Debug("The non-nullabale author property of the changeRequest {id} is null", changeRequest.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ChangeRequest FromJsonObject(JsonElement jsonElemen { if(classificationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale classification property of the changeRequest {id} is null", changeRequest.Iid); + Logger.Debug("The non-nullabale classification property of the changeRequest {id} is null", changeRequest.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ChangeRequest FromJsonObject(JsonElement jsonElemen { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the changeRequest {id} is null", changeRequest.Iid); + Logger.Debug("The non-nullabale content property of the changeRequest {id} is null", changeRequest.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ChangeRequest FromJsonObject(JsonElement jsonElemen { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the changeRequest {id} is null", changeRequest.Iid); + Logger.Debug("The non-nullabale createdOn property of the changeRequest {id} is null", changeRequest.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.ChangeRequest FromJsonObject(JsonElement jsonElemen { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the changeRequest {id} is null", changeRequest.Iid); + Logger.Debug("The non-nullabale languageCode property of the changeRequest {id} is null", changeRequest.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.ChangeRequest FromJsonObject(JsonElement jsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the changeRequest {id} is null", changeRequest.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the changeRequest {id} is null", changeRequest.Iid); } else { @@ -179,7 +179,7 @@ public static CDP4Common.DTO.ChangeRequest FromJsonObject(JsonElement jsonElemen { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the changeRequest {id} is null", changeRequest.Iid); + Logger.Debug("The non-nullabale owner property of the changeRequest {id} is null", changeRequest.Iid); } else { @@ -211,7 +211,7 @@ public static CDP4Common.DTO.ChangeRequest FromJsonObject(JsonElement jsonElemen { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the changeRequest {id} is null", changeRequest.Iid); + Logger.Debug("The non-nullabale shortName property of the changeRequest {id} is null", changeRequest.Iid); } else { @@ -231,7 +231,7 @@ public static CDP4Common.DTO.ChangeRequest FromJsonObject(JsonElement jsonElemen { if(statusProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale status property of the changeRequest {id} is null", changeRequest.Iid); + Logger.Debug("The non-nullabale status property of the changeRequest {id} is null", changeRequest.Iid); } else { @@ -243,7 +243,7 @@ public static CDP4Common.DTO.ChangeRequest FromJsonObject(JsonElement jsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the changeRequest {id} is null", changeRequest.Iid); + Logger.Debug("The non-nullabale thingPreference property of the changeRequest {id} is null", changeRequest.Iid); } else { @@ -255,7 +255,7 @@ public static CDP4Common.DTO.ChangeRequest FromJsonObject(JsonElement jsonElemen { if(titleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale title property of the changeRequest {id} is null", changeRequest.Iid); + Logger.Debug("The non-nullabale title property of the changeRequest {id} is null", changeRequest.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/CitationResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/CitationResolver.cs index aef860fc..7d4b2e3b 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/CitationResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/CitationResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.Citation FromJsonObject(JsonElement jsonElement) { if(isAdaptationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isAdaptation property of the citation {id} is null", citation.Iid); + Logger.Debug("The non-nullabale isAdaptation property of the citation {id} is null", citation.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.Citation FromJsonObject(JsonElement jsonElement) { if(locationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale location property of the citation {id} is null", citation.Iid); + Logger.Debug("The non-nullabale location property of the citation {id} is null", citation.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.Citation FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the citation {id} is null", citation.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the citation {id} is null", citation.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.Citation FromJsonObject(JsonElement jsonElement) { if(remarkProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale remark property of the citation {id} is null", citation.Iid); + Logger.Debug("The non-nullabale remark property of the citation {id} is null", citation.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Citation FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the citation {id} is null", citation.Iid); + Logger.Debug("The non-nullabale shortName property of the citation {id} is null", citation.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.Citation FromJsonObject(JsonElement jsonElement) { if(sourceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale source property of the citation {id} is null", citation.Iid); + Logger.Debug("The non-nullabale source property of the citation {id} is null", citation.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.Citation FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the citation {id} is null", citation.Iid); + Logger.Debug("The non-nullabale thingPreference property of the citation {id} is null", citation.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ColorResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ColorResolver.cs index ca61938e..10ad217a 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ColorResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ColorResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.Color FromJsonObject(JsonElement jsonElement) { if(blueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale blue property of the color {id} is null", color.Iid); + Logger.Debug("The non-nullabale blue property of the color {id} is null", color.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.Color FromJsonObject(JsonElement jsonElement) { if(greenProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale green property of the color {id} is null", color.Iid); + Logger.Debug("The non-nullabale green property of the color {id} is null", color.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.Color FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the color {id} is null", color.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the color {id} is null", color.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.Color FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the color {id} is null", color.Iid); + Logger.Debug("The non-nullabale name property of the color {id} is null", color.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Color FromJsonObject(JsonElement jsonElement) { if(redProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale red property of the color {id} is null", color.Iid); + Logger.Debug("The non-nullabale red property of the color {id} is null", color.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.Color FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the color {id} is null", color.Iid); + Logger.Debug("The non-nullabale thingPreference property of the color {id} is null", color.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/CommonFileStoreResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/CommonFileStoreResolver.cs index 0969d717..0b18fb31 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/CommonFileStoreResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/CommonFileStoreResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.CommonFileStore FromJsonObject(JsonElement jsonElem { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the commonFileStore {id} is null", commonFileStore.Iid); + Logger.Debug("The non-nullabale createdOn property of the commonFileStore {id} is null", commonFileStore.Iid); } else { @@ -111,7 +111,7 @@ public static CDP4Common.DTO.CommonFileStore FromJsonObject(JsonElement jsonElem { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the commonFileStore {id} is null", commonFileStore.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the commonFileStore {id} is null", commonFileStore.Iid); } else { @@ -123,7 +123,7 @@ public static CDP4Common.DTO.CommonFileStore FromJsonObject(JsonElement jsonElem { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the commonFileStore {id} is null", commonFileStore.Iid); + Logger.Debug("The non-nullabale name property of the commonFileStore {id} is null", commonFileStore.Iid); } else { @@ -135,7 +135,7 @@ public static CDP4Common.DTO.CommonFileStore FromJsonObject(JsonElement jsonElem { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the commonFileStore {id} is null", commonFileStore.Iid); + Logger.Debug("The non-nullabale owner property of the commonFileStore {id} is null", commonFileStore.Iid); } else { @@ -147,7 +147,7 @@ public static CDP4Common.DTO.CommonFileStore FromJsonObject(JsonElement jsonElem { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the commonFileStore {id} is null", commonFileStore.Iid); + Logger.Debug("The non-nullabale thingPreference property of the commonFileStore {id} is null", commonFileStore.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/CompoundParameterTypeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/CompoundParameterTypeResolver.cs index 39482bbd..565b835c 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/CompoundParameterTypeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/CompoundParameterTypeResolver.cs @@ -120,7 +120,7 @@ public static CDP4Common.DTO.CompoundParameterType FromJsonObject(JsonElement js { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the compoundParameterType {id} is null", compoundParameterType.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the compoundParameterType {id} is null", compoundParameterType.Iid); } else { @@ -132,7 +132,7 @@ public static CDP4Common.DTO.CompoundParameterType FromJsonObject(JsonElement js { if(isFinalizedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isFinalized property of the compoundParameterType {id} is null", compoundParameterType.Iid); + Logger.Debug("The non-nullabale isFinalized property of the compoundParameterType {id} is null", compoundParameterType.Iid); } else { @@ -144,7 +144,7 @@ public static CDP4Common.DTO.CompoundParameterType FromJsonObject(JsonElement js { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the compoundParameterType {id} is null", compoundParameterType.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the compoundParameterType {id} is null", compoundParameterType.Iid); } else { @@ -156,7 +156,7 @@ public static CDP4Common.DTO.CompoundParameterType FromJsonObject(JsonElement js { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the compoundParameterType {id} is null", compoundParameterType.Iid); + Logger.Debug("The non-nullabale name property of the compoundParameterType {id} is null", compoundParameterType.Iid); } else { @@ -168,7 +168,7 @@ public static CDP4Common.DTO.CompoundParameterType FromJsonObject(JsonElement js { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the compoundParameterType {id} is null", compoundParameterType.Iid); + Logger.Debug("The non-nullabale shortName property of the compoundParameterType {id} is null", compoundParameterType.Iid); } else { @@ -180,7 +180,7 @@ public static CDP4Common.DTO.CompoundParameterType FromJsonObject(JsonElement js { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the compoundParameterType {id} is null", compoundParameterType.Iid); + Logger.Debug("The non-nullabale symbol property of the compoundParameterType {id} is null", compoundParameterType.Iid); } else { @@ -192,7 +192,7 @@ public static CDP4Common.DTO.CompoundParameterType FromJsonObject(JsonElement js { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the compoundParameterType {id} is null", compoundParameterType.Iid); + Logger.Debug("The non-nullabale thingPreference property of the compoundParameterType {id} is null", compoundParameterType.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ConstantResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ConstantResolver.cs index 8b0bdcc6..c3219160 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ConstantResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ConstantResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.Constant FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the constant {id} is null", constant.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the constant {id} is null", constant.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.Constant FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the constant {id} is null", constant.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the constant {id} is null", constant.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.Constant FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the constant {id} is null", constant.Iid); + Logger.Debug("The non-nullabale name property of the constant {id} is null", constant.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.Constant FromJsonObject(JsonElement jsonElement) { if(parameterTypeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale parameterType property of the constant {id} is null", constant.Iid); + Logger.Debug("The non-nullabale parameterType property of the constant {id} is null", constant.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.Constant FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the constant {id} is null", constant.Iid); + Logger.Debug("The non-nullabale shortName property of the constant {id} is null", constant.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.Constant FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the constant {id} is null", constant.Iid); + Logger.Debug("The non-nullabale thingPreference property of the constant {id} is null", constant.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ContractChangeNoticeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ContractChangeNoticeResolver.cs index 2e902457..b4aa0b63 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ContractChangeNoticeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ContractChangeNoticeResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale author property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(changeProposalProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale changeProposal property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale changeProposal property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(classificationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale classification property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale classification property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale content property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale createdOn property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale languageCode property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { @@ -179,7 +179,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { @@ -191,7 +191,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale owner property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { @@ -223,7 +223,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale shortName property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { @@ -243,7 +243,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(statusProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale status property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale status property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { @@ -255,7 +255,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale thingPreference property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { @@ -267,7 +267,7 @@ public static CDP4Common.DTO.ContractChangeNotice FromJsonObject(JsonElement jso { if(titleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale title property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); + Logger.Debug("The non-nullabale title property of the contractChangeNotice {id} is null", contractChangeNotice.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/CyclicRatioScaleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/CyclicRatioScaleResolver.cs index 130ac64a..e479477f 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/CyclicRatioScaleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/CyclicRatioScaleResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(isMaximumInclusiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isMaximumInclusive property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale isMaximumInclusive property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(isMinimumInclusiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isMinimumInclusive property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale isMinimumInclusive property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(maximumPermissibleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale maximumPermissibleValue property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale maximumPermissibleValue property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(minimumPermissibleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale minimumPermissibleValue property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale minimumPermissibleValue property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(modulusProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modulus property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale modulus property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -199,7 +199,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale name property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -211,7 +211,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(negativeValueConnotationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale negativeValueConnotation property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale negativeValueConnotation property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -223,7 +223,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(numberSetProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale numberSet property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale numberSet property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -235,7 +235,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(positiveValueConnotationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale positiveValueConnotation property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale positiveValueConnotation property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -247,7 +247,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale shortName property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -259,7 +259,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale thingPreference property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { @@ -271,7 +271,7 @@ public static CDP4Common.DTO.CyclicRatioScale FromJsonObject(JsonElement jsonEle { if(unitProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale unit property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); + Logger.Debug("The non-nullabale unit property of the cyclicRatioScale {id} is null", cyclicRatioScale.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DateParameterTypeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DateParameterTypeResolver.cs index 0d19d7db..cedfd804 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DateParameterTypeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DateParameterTypeResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.DateParameterType FromJsonObject(JsonElement jsonEl { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the dateParameterType {id} is null", dateParameterType.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the dateParameterType {id} is null", dateParameterType.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.DateParameterType FromJsonObject(JsonElement jsonEl { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the dateParameterType {id} is null", dateParameterType.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the dateParameterType {id} is null", dateParameterType.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.DateParameterType FromJsonObject(JsonElement jsonEl { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the dateParameterType {id} is null", dateParameterType.Iid); + Logger.Debug("The non-nullabale name property of the dateParameterType {id} is null", dateParameterType.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.DateParameterType FromJsonObject(JsonElement jsonEl { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the dateParameterType {id} is null", dateParameterType.Iid); + Logger.Debug("The non-nullabale shortName property of the dateParameterType {id} is null", dateParameterType.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.DateParameterType FromJsonObject(JsonElement jsonEl { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the dateParameterType {id} is null", dateParameterType.Iid); + Logger.Debug("The non-nullabale symbol property of the dateParameterType {id} is null", dateParameterType.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.DateParameterType FromJsonObject(JsonElement jsonEl { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the dateParameterType {id} is null", dateParameterType.Iid); + Logger.Debug("The non-nullabale thingPreference property of the dateParameterType {id} is null", dateParameterType.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DateTimeParameterTypeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DateTimeParameterTypeResolver.cs index 25945772..397201bf 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DateTimeParameterTypeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DateTimeParameterTypeResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.DateTimeParameterType FromJsonObject(JsonElement js { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.DateTimeParameterType FromJsonObject(JsonElement js { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.DateTimeParameterType FromJsonObject(JsonElement js { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); + Logger.Debug("The non-nullabale name property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.DateTimeParameterType FromJsonObject(JsonElement js { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); + Logger.Debug("The non-nullabale shortName property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.DateTimeParameterType FromJsonObject(JsonElement js { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); + Logger.Debug("The non-nullabale symbol property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.DateTimeParameterType FromJsonObject(JsonElement js { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); + Logger.Debug("The non-nullabale thingPreference property of the dateTimeParameterType {id} is null", dateTimeParameterType.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DecompositionRuleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DecompositionRuleResolver.cs index a179dc8e..840efd27 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DecompositionRuleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DecompositionRuleResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.DecompositionRule FromJsonObject(JsonElement jsonEl { if(containingCategoryProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale containingCategory property of the decompositionRule {id} is null", decompositionRule.Iid); + Logger.Debug("The non-nullabale containingCategory property of the decompositionRule {id} is null", decompositionRule.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.DecompositionRule FromJsonObject(JsonElement jsonEl { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the decompositionRule {id} is null", decompositionRule.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the decompositionRule {id} is null", decompositionRule.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.DecompositionRule FromJsonObject(JsonElement jsonEl { if(minContainedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale minContained property of the decompositionRule {id} is null", decompositionRule.Iid); + Logger.Debug("The non-nullabale minContained property of the decompositionRule {id} is null", decompositionRule.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.DecompositionRule FromJsonObject(JsonElement jsonEl { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the decompositionRule {id} is null", decompositionRule.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the decompositionRule {id} is null", decompositionRule.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.DecompositionRule FromJsonObject(JsonElement jsonEl { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the decompositionRule {id} is null", decompositionRule.Iid); + Logger.Debug("The non-nullabale name property of the decompositionRule {id} is null", decompositionRule.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.DecompositionRule FromJsonObject(JsonElement jsonEl { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the decompositionRule {id} is null", decompositionRule.Iid); + Logger.Debug("The non-nullabale shortName property of the decompositionRule {id} is null", decompositionRule.Iid); } else { @@ -199,7 +199,7 @@ public static CDP4Common.DTO.DecompositionRule FromJsonObject(JsonElement jsonEl { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the decompositionRule {id} is null", decompositionRule.Iid); + Logger.Debug("The non-nullabale thingPreference property of the decompositionRule {id} is null", decompositionRule.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DefinitionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DefinitionResolver.cs index 3dbfce7c..9a90885b 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DefinitionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DefinitionResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.Definition FromJsonObject(JsonElement jsonElement) { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the definition {id} is null", definition.Iid); + Logger.Debug("The non-nullabale content property of the definition {id} is null", definition.Iid); } else { @@ -108,7 +108,7 @@ public static CDP4Common.DTO.Definition FromJsonObject(JsonElement jsonElement) { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the definition {id} is null", definition.Iid); + Logger.Debug("The non-nullabale languageCode property of the definition {id} is null", definition.Iid); } else { @@ -120,7 +120,7 @@ public static CDP4Common.DTO.Definition FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the definition {id} is null", definition.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the definition {id} is null", definition.Iid); } else { @@ -137,7 +137,7 @@ public static CDP4Common.DTO.Definition FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the definition {id} is null", definition.Iid); + Logger.Debug("The non-nullabale thingPreference property of the definition {id} is null", definition.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DependentParameterTypeAssignmentResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DependentParameterTypeAssignmentResolver.cs index 6cba4758..b424f62a 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DependentParameterTypeAssignmentResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DependentParameterTypeAssignmentResolver.cs @@ -95,7 +95,7 @@ public static CDP4Common.DTO.DependentParameterTypeAssignment FromJsonObject(Jso { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the dependentParameterTypeAssignment {id} is null", dependentParameterTypeAssignment.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the dependentParameterTypeAssignment {id} is null", dependentParameterTypeAssignment.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.DependentParameterTypeAssignment FromJsonObject(Jso { if(parameterTypeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale parameterType property of the dependentParameterTypeAssignment {id} is null", dependentParameterTypeAssignment.Iid); + Logger.Debug("The non-nullabale parameterType property of the dependentParameterTypeAssignment {id} is null", dependentParameterTypeAssignment.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.DependentParameterTypeAssignment FromJsonObject(Jso { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the dependentParameterTypeAssignment {id} is null", dependentParameterTypeAssignment.Iid); + Logger.Debug("The non-nullabale thingPreference property of the dependentParameterTypeAssignment {id} is null", dependentParameterTypeAssignment.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DerivedQuantityKindResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DerivedQuantityKindResolver.cs index 90fecb3f..351ed6f2 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DerivedQuantityKindResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DerivedQuantityKindResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.DerivedQuantityKind FromJsonObject(JsonElement json { if(defaultScaleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale defaultScale property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); + Logger.Debug("The non-nullabale defaultScale property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.DerivedQuantityKind FromJsonObject(JsonElement json { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.DerivedQuantityKind FromJsonObject(JsonElement json { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.DerivedQuantityKind FromJsonObject(JsonElement json { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); + Logger.Debug("The non-nullabale name property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); } else { @@ -171,7 +171,7 @@ public static CDP4Common.DTO.DerivedQuantityKind FromJsonObject(JsonElement json { if(quantityDimensionSymbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale quantityDimensionSymbol property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); + Logger.Debug("The non-nullabale quantityDimensionSymbol property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); } else { @@ -188,7 +188,7 @@ public static CDP4Common.DTO.DerivedQuantityKind FromJsonObject(JsonElement json { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); + Logger.Debug("The non-nullabale shortName property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); } else { @@ -200,7 +200,7 @@ public static CDP4Common.DTO.DerivedQuantityKind FromJsonObject(JsonElement json { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); + Logger.Debug("The non-nullabale symbol property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); } else { @@ -212,7 +212,7 @@ public static CDP4Common.DTO.DerivedQuantityKind FromJsonObject(JsonElement json { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); + Logger.Debug("The non-nullabale thingPreference property of the derivedQuantityKind {id} is null", derivedQuantityKind.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DerivedUnitResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DerivedUnitResolver.cs index 4346800f..84369200 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DerivedUnitResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DerivedUnitResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.DerivedUnit FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the derivedUnit {id} is null", derivedUnit.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the derivedUnit {id} is null", derivedUnit.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.DerivedUnit FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the derivedUnit {id} is null", derivedUnit.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the derivedUnit {id} is null", derivedUnit.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.DerivedUnit FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the derivedUnit {id} is null", derivedUnit.Iid); + Logger.Debug("The non-nullabale name property of the derivedUnit {id} is null", derivedUnit.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.DerivedUnit FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the derivedUnit {id} is null", derivedUnit.Iid); + Logger.Debug("The non-nullabale shortName property of the derivedUnit {id} is null", derivedUnit.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.DerivedUnit FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the derivedUnit {id} is null", derivedUnit.Iid); + Logger.Debug("The non-nullabale thingPreference property of the derivedUnit {id} is null", derivedUnit.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramCanvasResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramCanvasResolver.cs index 7ded4b61..eb1f7514 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramCanvasResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramCanvasResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.DiagramCanvas FromJsonObject(JsonElement jsonElemen { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the diagramCanvas {id} is null", diagramCanvas.Iid); + Logger.Debug("The non-nullabale createdOn property of the diagramCanvas {id} is null", diagramCanvas.Iid); } else { @@ -111,7 +111,7 @@ public static CDP4Common.DTO.DiagramCanvas FromJsonObject(JsonElement jsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the diagramCanvas {id} is null", diagramCanvas.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the diagramCanvas {id} is null", diagramCanvas.Iid); } else { @@ -123,7 +123,7 @@ public static CDP4Common.DTO.DiagramCanvas FromJsonObject(JsonElement jsonElemen { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the diagramCanvas {id} is null", diagramCanvas.Iid); + Logger.Debug("The non-nullabale name property of the diagramCanvas {id} is null", diagramCanvas.Iid); } else { @@ -135,7 +135,7 @@ public static CDP4Common.DTO.DiagramCanvas FromJsonObject(JsonElement jsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the diagramCanvas {id} is null", diagramCanvas.Iid); + Logger.Debug("The non-nullabale thingPreference property of the diagramCanvas {id} is null", diagramCanvas.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramEdgeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramEdgeResolver.cs index dd993465..c5e8aff1 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramEdgeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramEdgeResolver.cs @@ -119,7 +119,7 @@ public static CDP4Common.DTO.DiagramEdge FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the diagramEdge {id} is null", diagramEdge.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the diagramEdge {id} is null", diagramEdge.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.DiagramEdge FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the diagramEdge {id} is null", diagramEdge.Iid); + Logger.Debug("The non-nullabale name property of the diagramEdge {id} is null", diagramEdge.Iid); } else { @@ -160,7 +160,7 @@ public static CDP4Common.DTO.DiagramEdge FromJsonObject(JsonElement jsonElement) { if(sourceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale source property of the diagramEdge {id} is null", diagramEdge.Iid); + Logger.Debug("The non-nullabale source property of the diagramEdge {id} is null", diagramEdge.Iid); } else { @@ -172,7 +172,7 @@ public static CDP4Common.DTO.DiagramEdge FromJsonObject(JsonElement jsonElement) { if(targetProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale target property of the diagramEdge {id} is null", diagramEdge.Iid); + Logger.Debug("The non-nullabale target property of the diagramEdge {id} is null", diagramEdge.Iid); } else { @@ -184,7 +184,7 @@ public static CDP4Common.DTO.DiagramEdge FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the diagramEdge {id} is null", diagramEdge.Iid); + Logger.Debug("The non-nullabale thingPreference property of the diagramEdge {id} is null", diagramEdge.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramObjectResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramObjectResolver.cs index 4477d81c..be0d7776 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramObjectResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DiagramObjectResolver.cs @@ -95,7 +95,7 @@ public static CDP4Common.DTO.DiagramObject FromJsonObject(JsonElement jsonElemen { if(documentationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale documentation property of the diagramObject {id} is null", diagramObject.Iid); + Logger.Debug("The non-nullabale documentation property of the diagramObject {id} is null", diagramObject.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.DiagramObject FromJsonObject(JsonElement jsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the diagramObject {id} is null", diagramObject.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the diagramObject {id} is null", diagramObject.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.DiagramObject FromJsonObject(JsonElement jsonElemen { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the diagramObject {id} is null", diagramObject.Iid); + Logger.Debug("The non-nullabale name property of the diagramObject {id} is null", diagramObject.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.DiagramObject FromJsonObject(JsonElement jsonElemen { if(resolutionProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale resolution property of the diagramObject {id} is null", diagramObject.Iid); + Logger.Debug("The non-nullabale resolution property of the diagramObject {id} is null", diagramObject.Iid); } else { @@ -179,7 +179,7 @@ public static CDP4Common.DTO.DiagramObject FromJsonObject(JsonElement jsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the diagramObject {id} is null", diagramObject.Iid); + Logger.Debug("The non-nullabale thingPreference property of the diagramObject {id} is null", diagramObject.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainFileStoreResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainFileStoreResolver.cs index 1f173b3d..5c95e266 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainFileStoreResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainFileStoreResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.DomainFileStore FromJsonObject(JsonElement jsonElem { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the domainFileStore {id} is null", domainFileStore.Iid); + Logger.Debug("The non-nullabale createdOn property of the domainFileStore {id} is null", domainFileStore.Iid); } else { @@ -111,7 +111,7 @@ public static CDP4Common.DTO.DomainFileStore FromJsonObject(JsonElement jsonElem { if(isHiddenProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isHidden property of the domainFileStore {id} is null", domainFileStore.Iid); + Logger.Debug("The non-nullabale isHidden property of the domainFileStore {id} is null", domainFileStore.Iid); } else { @@ -123,7 +123,7 @@ public static CDP4Common.DTO.DomainFileStore FromJsonObject(JsonElement jsonElem { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the domainFileStore {id} is null", domainFileStore.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the domainFileStore {id} is null", domainFileStore.Iid); } else { @@ -135,7 +135,7 @@ public static CDP4Common.DTO.DomainFileStore FromJsonObject(JsonElement jsonElem { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the domainFileStore {id} is null", domainFileStore.Iid); + Logger.Debug("The non-nullabale name property of the domainFileStore {id} is null", domainFileStore.Iid); } else { @@ -147,7 +147,7 @@ public static CDP4Common.DTO.DomainFileStore FromJsonObject(JsonElement jsonElem { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the domainFileStore {id} is null", domainFileStore.Iid); + Logger.Debug("The non-nullabale owner property of the domainFileStore {id} is null", domainFileStore.Iid); } else { @@ -159,7 +159,7 @@ public static CDP4Common.DTO.DomainFileStore FromJsonObject(JsonElement jsonElem { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the domainFileStore {id} is null", domainFileStore.Iid); + Logger.Debug("The non-nullabale thingPreference property of the domainFileStore {id} is null", domainFileStore.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainOfExpertiseGroupResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainOfExpertiseGroupResolver.cs index 59571a59..84203638 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainOfExpertiseGroupResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainOfExpertiseGroupResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.DomainOfExpertiseGroup FromJsonObject(JsonElement j { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the domainOfExpertiseGroup {id} is null", domainOfExpertiseGroup.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the domainOfExpertiseGroup {id} is null", domainOfExpertiseGroup.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.DomainOfExpertiseGroup FromJsonObject(JsonElement j { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the domainOfExpertiseGroup {id} is null", domainOfExpertiseGroup.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the domainOfExpertiseGroup {id} is null", domainOfExpertiseGroup.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.DomainOfExpertiseGroup FromJsonObject(JsonElement j { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the domainOfExpertiseGroup {id} is null", domainOfExpertiseGroup.Iid); + Logger.Debug("The non-nullabale name property of the domainOfExpertiseGroup {id} is null", domainOfExpertiseGroup.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.DomainOfExpertiseGroup FromJsonObject(JsonElement j { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the domainOfExpertiseGroup {id} is null", domainOfExpertiseGroup.Iid); + Logger.Debug("The non-nullabale shortName property of the domainOfExpertiseGroup {id} is null", domainOfExpertiseGroup.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.DomainOfExpertiseGroup FromJsonObject(JsonElement j { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the domainOfExpertiseGroup {id} is null", domainOfExpertiseGroup.Iid); + Logger.Debug("The non-nullabale thingPreference property of the domainOfExpertiseGroup {id} is null", domainOfExpertiseGroup.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainOfExpertiseResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainOfExpertiseResolver.cs index e81c0408..06cf5521 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainOfExpertiseResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/DomainOfExpertiseResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.DomainOfExpertise FromJsonObject(JsonElement jsonEl { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the domainOfExpertise {id} is null", domainOfExpertise.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the domainOfExpertise {id} is null", domainOfExpertise.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.DomainOfExpertise FromJsonObject(JsonElement jsonEl { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the domainOfExpertise {id} is null", domainOfExpertise.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the domainOfExpertise {id} is null", domainOfExpertise.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.DomainOfExpertise FromJsonObject(JsonElement jsonEl { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the domainOfExpertise {id} is null", domainOfExpertise.Iid); + Logger.Debug("The non-nullabale name property of the domainOfExpertise {id} is null", domainOfExpertise.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.DomainOfExpertise FromJsonObject(JsonElement jsonEl { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the domainOfExpertise {id} is null", domainOfExpertise.Iid); + Logger.Debug("The non-nullabale shortName property of the domainOfExpertise {id} is null", domainOfExpertise.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.DomainOfExpertise FromJsonObject(JsonElement jsonEl { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the domainOfExpertise {id} is null", domainOfExpertise.Iid); + Logger.Debug("The non-nullabale thingPreference property of the domainOfExpertise {id} is null", domainOfExpertise.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ElementDefinitionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ElementDefinitionResolver.cs index 5713aa4f..91c5c81b 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ElementDefinitionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ElementDefinitionResolver.cs @@ -123,7 +123,7 @@ public static CDP4Common.DTO.ElementDefinition FromJsonObject(JsonElement jsonEl { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the elementDefinition {id} is null", elementDefinition.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the elementDefinition {id} is null", elementDefinition.Iid); } else { @@ -135,7 +135,7 @@ public static CDP4Common.DTO.ElementDefinition FromJsonObject(JsonElement jsonEl { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the elementDefinition {id} is null", elementDefinition.Iid); + Logger.Debug("The non-nullabale name property of the elementDefinition {id} is null", elementDefinition.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.ElementDefinition FromJsonObject(JsonElement jsonEl { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the elementDefinition {id} is null", elementDefinition.Iid); + Logger.Debug("The non-nullabale owner property of the elementDefinition {id} is null", elementDefinition.Iid); } else { @@ -191,7 +191,7 @@ public static CDP4Common.DTO.ElementDefinition FromJsonObject(JsonElement jsonEl { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the elementDefinition {id} is null", elementDefinition.Iid); + Logger.Debug("The non-nullabale shortName property of the elementDefinition {id} is null", elementDefinition.Iid); } else { @@ -203,7 +203,7 @@ public static CDP4Common.DTO.ElementDefinition FromJsonObject(JsonElement jsonEl { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the elementDefinition {id} is null", elementDefinition.Iid); + Logger.Debug("The non-nullabale thingPreference property of the elementDefinition {id} is null", elementDefinition.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ElementUsageResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ElementUsageResolver.cs index 56f20ecf..8406d81e 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ElementUsageResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ElementUsageResolver.cs @@ -91,7 +91,7 @@ public static CDP4Common.DTO.ElementUsage FromJsonObject(JsonElement jsonElement { if(elementDefinitionProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale elementDefinition property of the elementUsage {id} is null", elementUsage.Iid); + Logger.Debug("The non-nullabale elementDefinition property of the elementUsage {id} is null", elementUsage.Iid); } else { @@ -135,7 +135,7 @@ public static CDP4Common.DTO.ElementUsage FromJsonObject(JsonElement jsonElement { if(interfaceEndProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale interfaceEnd property of the elementUsage {id} is null", elementUsage.Iid); + Logger.Debug("The non-nullabale interfaceEnd property of the elementUsage {id} is null", elementUsage.Iid); } else { @@ -147,7 +147,7 @@ public static CDP4Common.DTO.ElementUsage FromJsonObject(JsonElement jsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the elementUsage {id} is null", elementUsage.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the elementUsage {id} is null", elementUsage.Iid); } else { @@ -159,7 +159,7 @@ public static CDP4Common.DTO.ElementUsage FromJsonObject(JsonElement jsonElement { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the elementUsage {id} is null", elementUsage.Iid); + Logger.Debug("The non-nullabale name property of the elementUsage {id} is null", elementUsage.Iid); } else { @@ -171,7 +171,7 @@ public static CDP4Common.DTO.ElementUsage FromJsonObject(JsonElement jsonElement { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the elementUsage {id} is null", elementUsage.Iid); + Logger.Debug("The non-nullabale owner property of the elementUsage {id} is null", elementUsage.Iid); } else { @@ -191,7 +191,7 @@ public static CDP4Common.DTO.ElementUsage FromJsonObject(JsonElement jsonElement { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the elementUsage {id} is null", elementUsage.Iid); + Logger.Debug("The non-nullabale shortName property of the elementUsage {id} is null", elementUsage.Iid); } else { @@ -203,7 +203,7 @@ public static CDP4Common.DTO.ElementUsage FromJsonObject(JsonElement jsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the elementUsage {id} is null", elementUsage.Iid); + Logger.Debug("The non-nullabale thingPreference property of the elementUsage {id} is null", elementUsage.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/EmailAddressResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/EmailAddressResolver.cs index 7d7d3bea..de0fbc23 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/EmailAddressResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/EmailAddressResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.EmailAddress FromJsonObject(JsonElement jsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the emailAddress {id} is null", emailAddress.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the emailAddress {id} is null", emailAddress.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.EmailAddress FromJsonObject(JsonElement jsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the emailAddress {id} is null", emailAddress.Iid); + Logger.Debug("The non-nullabale thingPreference property of the emailAddress {id} is null", emailAddress.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.EmailAddress FromJsonObject(JsonElement jsonElement { if(valueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale value property of the emailAddress {id} is null", emailAddress.Iid); + Logger.Debug("The non-nullabale value property of the emailAddress {id} is null", emailAddress.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.EmailAddress FromJsonObject(JsonElement jsonElement { if(vcardTypeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale vcardType property of the emailAddress {id} is null", emailAddress.Iid); + Logger.Debug("The non-nullabale vcardType property of the emailAddress {id} is null", emailAddress.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelDataDiscussionItemResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelDataDiscussionItemResolver.cs index 4a27537a..3cd779c8 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelDataDiscussionItemResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelDataDiscussionItemResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.EngineeringModelDataDiscussionItem FromJsonObject(J { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale author property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); } else { @@ -79,7 +79,7 @@ public static CDP4Common.DTO.EngineeringModelDataDiscussionItem FromJsonObject(J { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale content property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); } else { @@ -91,7 +91,7 @@ public static CDP4Common.DTO.EngineeringModelDataDiscussionItem FromJsonObject(J { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale createdOn property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.EngineeringModelDataDiscussionItem FromJsonObject(J { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale languageCode property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.EngineeringModelDataDiscussionItem FromJsonObject(J { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.EngineeringModelDataDiscussionItem FromJsonObject(J { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale thingPreference property of the engineeringModelDataDiscussionItem {id} is null", engineeringModelDataDiscussionItem.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelDataNoteResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelDataNoteResolver.cs index 5c1508d8..d49355db 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelDataNoteResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelDataNoteResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.EngineeringModelDataNote FromJsonObject(JsonElement { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); + Logger.Debug("The non-nullabale author property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); } else { @@ -79,7 +79,7 @@ public static CDP4Common.DTO.EngineeringModelDataNote FromJsonObject(JsonElement { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); + Logger.Debug("The non-nullabale content property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); } else { @@ -91,7 +91,7 @@ public static CDP4Common.DTO.EngineeringModelDataNote FromJsonObject(JsonElement { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); + Logger.Debug("The non-nullabale createdOn property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.EngineeringModelDataNote FromJsonObject(JsonElement { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); + Logger.Debug("The non-nullabale languageCode property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.EngineeringModelDataNote FromJsonObject(JsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); } else { @@ -171,7 +171,7 @@ public static CDP4Common.DTO.EngineeringModelDataNote FromJsonObject(JsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); + Logger.Debug("The non-nullabale thingPreference property of the engineeringModelDataNote {id} is null", engineeringModelDataNote.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelResolver.cs index aeac88ff..f4f0ac12 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelResolver.cs @@ -80,7 +80,7 @@ public static CDP4Common.DTO.EngineeringModel FromJsonObject(JsonElement jsonEle { if(engineeringModelSetupProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale engineeringModelSetup property of the engineeringModel {id} is null", engineeringModel.Iid); + Logger.Debug("The non-nullabale engineeringModelSetup property of the engineeringModel {id} is null", engineeringModel.Iid); } else { @@ -124,7 +124,7 @@ public static CDP4Common.DTO.EngineeringModel FromJsonObject(JsonElement jsonEle { if(lastModifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale lastModifiedOn property of the engineeringModel {id} is null", engineeringModel.Iid); + Logger.Debug("The non-nullabale lastModifiedOn property of the engineeringModel {id} is null", engineeringModel.Iid); } else { @@ -152,7 +152,7 @@ public static CDP4Common.DTO.EngineeringModel FromJsonObject(JsonElement jsonEle { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the engineeringModel {id} is null", engineeringModel.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the engineeringModel {id} is null", engineeringModel.Iid); } else { @@ -164,7 +164,7 @@ public static CDP4Common.DTO.EngineeringModel FromJsonObject(JsonElement jsonEle { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the engineeringModel {id} is null", engineeringModel.Iid); + Logger.Debug("The non-nullabale thingPreference property of the engineeringModel {id} is null", engineeringModel.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelSetupResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelSetupResolver.cs index 1ce062d0..a0a05f28 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelSetupResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/EngineeringModelSetupResolver.cs @@ -103,7 +103,7 @@ public static CDP4Common.DTO.EngineeringModelSetup FromJsonObject(JsonElement js { if(engineeringModelIidProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale engineeringModelIid property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); + Logger.Debug("The non-nullabale engineeringModelIid property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); } else { @@ -147,7 +147,7 @@ public static CDP4Common.DTO.EngineeringModelSetup FromJsonObject(JsonElement js { if(kindProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale kind property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); + Logger.Debug("The non-nullabale kind property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); } else { @@ -159,7 +159,7 @@ public static CDP4Common.DTO.EngineeringModelSetup FromJsonObject(JsonElement js { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); } else { @@ -171,7 +171,7 @@ public static CDP4Common.DTO.EngineeringModelSetup FromJsonObject(JsonElement js { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); + Logger.Debug("The non-nullabale name property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); } else { @@ -207,7 +207,7 @@ public static CDP4Common.DTO.EngineeringModelSetup FromJsonObject(JsonElement js { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); + Logger.Debug("The non-nullabale shortName property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); } else { @@ -231,7 +231,7 @@ public static CDP4Common.DTO.EngineeringModelSetup FromJsonObject(JsonElement js { if(studyPhaseProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale studyPhase property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); + Logger.Debug("The non-nullabale studyPhase property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); } else { @@ -243,7 +243,7 @@ public static CDP4Common.DTO.EngineeringModelSetup FromJsonObject(JsonElement js { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); + Logger.Debug("The non-nullabale thingPreference property of the engineeringModelSetup {id} is null", engineeringModelSetup.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/EnumerationParameterTypeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/EnumerationParameterTypeResolver.cs index d3837abd..6059bd7a 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/EnumerationParameterTypeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/EnumerationParameterTypeResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.EnumerationParameterType FromJsonObject(JsonElement { if(allowMultiSelectProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale allowMultiSelect property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); + Logger.Debug("The non-nullabale allowMultiSelect property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.EnumerationParameterType FromJsonObject(JsonElement { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.EnumerationParameterType FromJsonObject(JsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.EnumerationParameterType FromJsonObject(JsonElement { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); + Logger.Debug("The non-nullabale name property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.EnumerationParameterType FromJsonObject(JsonElement { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); + Logger.Debug("The non-nullabale shortName property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.EnumerationParameterType FromJsonObject(JsonElement { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); + Logger.Debug("The non-nullabale symbol property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.EnumerationParameterType FromJsonObject(JsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); + Logger.Debug("The non-nullabale thingPreference property of the enumerationParameterType {id} is null", enumerationParameterType.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/EnumerationValueDefinitionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/EnumerationValueDefinitionResolver.cs index 5fa2053a..b0db8660 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/EnumerationValueDefinitionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/EnumerationValueDefinitionResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.EnumerationValueDefinition FromJsonObject(JsonEleme { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the enumerationValueDefinition {id} is null", enumerationValueDefinition.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the enumerationValueDefinition {id} is null", enumerationValueDefinition.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.EnumerationValueDefinition FromJsonObject(JsonEleme { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the enumerationValueDefinition {id} is null", enumerationValueDefinition.Iid); + Logger.Debug("The non-nullabale name property of the enumerationValueDefinition {id} is null", enumerationValueDefinition.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.EnumerationValueDefinition FromJsonObject(JsonEleme { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the enumerationValueDefinition {id} is null", enumerationValueDefinition.Iid); + Logger.Debug("The non-nullabale shortName property of the enumerationValueDefinition {id} is null", enumerationValueDefinition.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.EnumerationValueDefinition FromJsonObject(JsonEleme { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the enumerationValueDefinition {id} is null", enumerationValueDefinition.Iid); + Logger.Debug("The non-nullabale thingPreference property of the enumerationValueDefinition {id} is null", enumerationValueDefinition.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ExclusiveOrExpressionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ExclusiveOrExpressionResolver.cs index 1f8ab386..62d37fbb 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ExclusiveOrExpressionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ExclusiveOrExpressionResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.ExclusiveOrExpression FromJsonObject(JsonElement js { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the exclusiveOrExpression {id} is null", exclusiveOrExpression.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the exclusiveOrExpression {id} is null", exclusiveOrExpression.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.ExclusiveOrExpression FromJsonObject(JsonElement js { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the exclusiveOrExpression {id} is null", exclusiveOrExpression.Iid); + Logger.Debug("The non-nullabale thingPreference property of the exclusiveOrExpression {id} is null", exclusiveOrExpression.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ExternalIdentifierMapResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ExternalIdentifierMapResolver.cs index 04c37e0f..242f14aa 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ExternalIdentifierMapResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ExternalIdentifierMapResolver.cs @@ -103,7 +103,7 @@ public static CDP4Common.DTO.ExternalIdentifierMap FromJsonObject(JsonElement js { if(externalModelNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale externalModelName property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); + Logger.Debug("The non-nullabale externalModelName property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.ExternalIdentifierMap FromJsonObject(JsonElement js { if(externalToolNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale externalToolName property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); + Logger.Debug("The non-nullabale externalToolName property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.ExternalIdentifierMap FromJsonObject(JsonElement js { if(externalToolVersionProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale externalToolVersion property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); + Logger.Debug("The non-nullabale externalToolVersion property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.ExternalIdentifierMap FromJsonObject(JsonElement js { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.ExternalIdentifierMap FromJsonObject(JsonElement js { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); + Logger.Debug("The non-nullabale name property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.ExternalIdentifierMap FromJsonObject(JsonElement js { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); + Logger.Debug("The non-nullabale owner property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.ExternalIdentifierMap FromJsonObject(JsonElement js { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); + Logger.Debug("The non-nullabale thingPreference property of the externalIdentifierMap {id} is null", externalIdentifierMap.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/FileResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/FileResolver.cs index c07ae429..d7f52a5d 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/FileResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/FileResolver.cs @@ -111,7 +111,7 @@ public static CDP4Common.DTO.File FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the file {id} is null", file.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the file {id} is null", file.Iid); } else { @@ -123,7 +123,7 @@ public static CDP4Common.DTO.File FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the file {id} is null", file.Iid); + Logger.Debug("The non-nullabale owner property of the file {id} is null", file.Iid); } else { @@ -135,7 +135,7 @@ public static CDP4Common.DTO.File FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the file {id} is null", file.Iid); + Logger.Debug("The non-nullabale thingPreference property of the file {id} is null", file.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/FileRevisionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/FileRevisionResolver.cs index 18301149..e7dc7b9b 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/FileRevisionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/FileRevisionResolver.cs @@ -79,7 +79,7 @@ public static CDP4Common.DTO.FileRevision FromJsonObject(JsonElement jsonElement { if(contentHashProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale contentHash property of the fileRevision {id} is null", fileRevision.Iid); + Logger.Debug("The non-nullabale contentHash property of the fileRevision {id} is null", fileRevision.Iid); } else { @@ -91,7 +91,7 @@ public static CDP4Common.DTO.FileRevision FromJsonObject(JsonElement jsonElement { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the fileRevision {id} is null", fileRevision.Iid); + Logger.Debug("The non-nullabale createdOn property of the fileRevision {id} is null", fileRevision.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.FileRevision FromJsonObject(JsonElement jsonElement { if(creatorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale creator property of the fileRevision {id} is null", fileRevision.Iid); + Logger.Debug("The non-nullabale creator property of the fileRevision {id} is null", fileRevision.Iid); } else { @@ -136,7 +136,7 @@ public static CDP4Common.DTO.FileRevision FromJsonObject(JsonElement jsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the fileRevision {id} is null", fileRevision.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the fileRevision {id} is null", fileRevision.Iid); } else { @@ -148,7 +148,7 @@ public static CDP4Common.DTO.FileRevision FromJsonObject(JsonElement jsonElement { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the fileRevision {id} is null", fileRevision.Iid); + Logger.Debug("The non-nullabale name property of the fileRevision {id} is null", fileRevision.Iid); } else { @@ -160,7 +160,7 @@ public static CDP4Common.DTO.FileRevision FromJsonObject(JsonElement jsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the fileRevision {id} is null", fileRevision.Iid); + Logger.Debug("The non-nullabale thingPreference property of the fileRevision {id} is null", fileRevision.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/FileTypeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/FileTypeResolver.cs index 743c5834..15a415fa 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/FileTypeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/FileTypeResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.FileType FromJsonObject(JsonElement jsonElement) { if(extensionProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale extension property of the fileType {id} is null", fileType.Iid); + Logger.Debug("The non-nullabale extension property of the fileType {id} is null", fileType.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.FileType FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the fileType {id} is null", fileType.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the fileType {id} is null", fileType.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.FileType FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the fileType {id} is null", fileType.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the fileType {id} is null", fileType.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.FileType FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the fileType {id} is null", fileType.Iid); + Logger.Debug("The non-nullabale name property of the fileType {id} is null", fileType.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.FileType FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the fileType {id} is null", fileType.Iid); + Logger.Debug("The non-nullabale shortName property of the fileType {id} is null", fileType.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.FileType FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the fileType {id} is null", fileType.Iid); + Logger.Debug("The non-nullabale thingPreference property of the fileType {id} is null", fileType.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/FolderResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/FolderResolver.cs index a15b5feb..61957f20 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/FolderResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/FolderResolver.cs @@ -79,7 +79,7 @@ public static CDP4Common.DTO.Folder FromJsonObject(JsonElement jsonElement) { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the folder {id} is null", folder.Iid); + Logger.Debug("The non-nullabale createdOn property of the folder {id} is null", folder.Iid); } else { @@ -91,7 +91,7 @@ public static CDP4Common.DTO.Folder FromJsonObject(JsonElement jsonElement) { if(creatorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale creator property of the folder {id} is null", folder.Iid); + Logger.Debug("The non-nullabale creator property of the folder {id} is null", folder.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.Folder FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the folder {id} is null", folder.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the folder {id} is null", folder.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Folder FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the folder {id} is null", folder.Iid); + Logger.Debug("The non-nullabale name property of the folder {id} is null", folder.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.Folder FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the folder {id} is null", folder.Iid); + Logger.Debug("The non-nullabale owner property of the folder {id} is null", folder.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.Folder FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the folder {id} is null", folder.Iid); + Logger.Debug("The non-nullabale thingPreference property of the folder {id} is null", folder.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/GlossaryResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/GlossaryResolver.cs index 0f233c96..0b62a5f6 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/GlossaryResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/GlossaryResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.Glossary FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the glossary {id} is null", glossary.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the glossary {id} is null", glossary.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.Glossary FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the glossary {id} is null", glossary.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the glossary {id} is null", glossary.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.Glossary FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the glossary {id} is null", glossary.Iid); + Logger.Debug("The non-nullabale name property of the glossary {id} is null", glossary.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.Glossary FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the glossary {id} is null", glossary.Iid); + Logger.Debug("The non-nullabale shortName property of the glossary {id} is null", glossary.Iid); } else { @@ -171,7 +171,7 @@ public static CDP4Common.DTO.Glossary FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the glossary {id} is null", glossary.Iid); + Logger.Debug("The non-nullabale thingPreference property of the glossary {id} is null", glossary.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/GoalResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/GoalResolver.cs index be107d3a..add132c0 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/GoalResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/GoalResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.Goal FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the goal {id} is null", goal.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the goal {id} is null", goal.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.Goal FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the goal {id} is null", goal.Iid); + Logger.Debug("The non-nullabale name property of the goal {id} is null", goal.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.Goal FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the goal {id} is null", goal.Iid); + Logger.Debug("The non-nullabale shortName property of the goal {id} is null", goal.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.Goal FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the goal {id} is null", goal.Iid); + Logger.Debug("The non-nullabale thingPreference property of the goal {id} is null", goal.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/HyperLinkResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/HyperLinkResolver.cs index 8b5405de..2a47f983 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/HyperLinkResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/HyperLinkResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.HyperLink FromJsonObject(JsonElement jsonElement) { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the hyperLink {id} is null", hyperLink.Iid); + Logger.Debug("The non-nullabale content property of the hyperLink {id} is null", hyperLink.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.HyperLink FromJsonObject(JsonElement jsonElement) { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the hyperLink {id} is null", hyperLink.Iid); + Logger.Debug("The non-nullabale languageCode property of the hyperLink {id} is null", hyperLink.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.HyperLink FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the hyperLink {id} is null", hyperLink.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the hyperLink {id} is null", hyperLink.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.HyperLink FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the hyperLink {id} is null", hyperLink.Iid); + Logger.Debug("The non-nullabale thingPreference property of the hyperLink {id} is null", hyperLink.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.HyperLink FromJsonObject(JsonElement jsonElement) { if(uriProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale uri property of the hyperLink {id} is null", hyperLink.Iid); + Logger.Debug("The non-nullabale uri property of the hyperLink {id} is null", hyperLink.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/IdCorrespondenceResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/IdCorrespondenceResolver.cs index bcbf34af..dc573c68 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/IdCorrespondenceResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/IdCorrespondenceResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.IdCorrespondence FromJsonObject(JsonElement jsonEle { if(externalIdProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale externalId property of the idCorrespondence {id} is null", idCorrespondence.Iid); + Logger.Debug("The non-nullabale externalId property of the idCorrespondence {id} is null", idCorrespondence.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.IdCorrespondence FromJsonObject(JsonElement jsonEle { if(internalThingProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale internalThing property of the idCorrespondence {id} is null", idCorrespondence.Iid); + Logger.Debug("The non-nullabale internalThing property of the idCorrespondence {id} is null", idCorrespondence.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.IdCorrespondence FromJsonObject(JsonElement jsonEle { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the idCorrespondence {id} is null", idCorrespondence.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the idCorrespondence {id} is null", idCorrespondence.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.IdCorrespondence FromJsonObject(JsonElement jsonEle { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the idCorrespondence {id} is null", idCorrespondence.Iid); + Logger.Debug("The non-nullabale thingPreference property of the idCorrespondence {id} is null", idCorrespondence.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/IndependentParameterTypeAssignmentResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/IndependentParameterTypeAssignmentResolver.cs index ad3bd6f9..2d8f77bb 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/IndependentParameterTypeAssignmentResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/IndependentParameterTypeAssignmentResolver.cs @@ -95,7 +95,7 @@ public static CDP4Common.DTO.IndependentParameterTypeAssignment FromJsonObject(J { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the independentParameterTypeAssignment {id} is null", independentParameterTypeAssignment.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the independentParameterTypeAssignment {id} is null", independentParameterTypeAssignment.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.IndependentParameterTypeAssignment FromJsonObject(J { if(parameterTypeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale parameterType property of the independentParameterTypeAssignment {id} is null", independentParameterTypeAssignment.Iid); + Logger.Debug("The non-nullabale parameterType property of the independentParameterTypeAssignment {id} is null", independentParameterTypeAssignment.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.IndependentParameterTypeAssignment FromJsonObject(J { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the independentParameterTypeAssignment {id} is null", independentParameterTypeAssignment.Iid); + Logger.Debug("The non-nullabale thingPreference property of the independentParameterTypeAssignment {id} is null", independentParameterTypeAssignment.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/IntervalScaleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/IntervalScaleResolver.cs index 0dd94eb4..ca2a5d4c 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/IntervalScaleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/IntervalScaleResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(isMaximumInclusiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isMaximumInclusive property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale isMaximumInclusive property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(isMinimumInclusiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isMinimumInclusive property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale isMinimumInclusive property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(maximumPermissibleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale maximumPermissibleValue property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale maximumPermissibleValue property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(minimumPermissibleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale minimumPermissibleValue property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale minimumPermissibleValue property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale name property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -199,7 +199,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(negativeValueConnotationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale negativeValueConnotation property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale negativeValueConnotation property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -211,7 +211,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(numberSetProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale numberSet property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale numberSet property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -223,7 +223,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(positiveValueConnotationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale positiveValueConnotation property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale positiveValueConnotation property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -235,7 +235,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale shortName property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -247,7 +247,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale thingPreference property of the intervalScale {id} is null", intervalScale.Iid); } else { @@ -259,7 +259,7 @@ public static CDP4Common.DTO.IntervalScale FromJsonObject(JsonElement jsonElemen { if(unitProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale unit property of the intervalScale {id} is null", intervalScale.Iid); + Logger.Debug("The non-nullabale unit property of the intervalScale {id} is null", intervalScale.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/IterationResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/IterationResolver.cs index c98d0a97..ffc947b3 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/IterationResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/IterationResolver.cs @@ -143,7 +143,7 @@ public static CDP4Common.DTO.Iteration FromJsonObject(JsonElement jsonElement) { if(iterationSetupProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale iterationSetup property of the iteration {id} is null", iteration.Iid); + Logger.Debug("The non-nullabale iterationSetup property of the iteration {id} is null", iteration.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.Iteration FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the iteration {id} is null", iteration.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the iteration {id} is null", iteration.Iid); } else { @@ -256,7 +256,7 @@ public static CDP4Common.DTO.Iteration FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the iteration {id} is null", iteration.Iid); + Logger.Debug("The non-nullabale thingPreference property of the iteration {id} is null", iteration.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/IterationSetupResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/IterationSetupResolver.cs index 74109e6a..c8e8447f 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/IterationSetupResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/IterationSetupResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.IterationSetup FromJsonObject(JsonElement jsonEleme { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the iterationSetup {id} is null", iterationSetup.Iid); + Logger.Debug("The non-nullabale createdOn property of the iterationSetup {id} is null", iterationSetup.Iid); } else { @@ -79,7 +79,7 @@ public static CDP4Common.DTO.IterationSetup FromJsonObject(JsonElement jsonEleme { if(descriptionProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale description property of the iterationSetup {id} is null", iterationSetup.Iid); + Logger.Debug("The non-nullabale description property of the iterationSetup {id} is null", iterationSetup.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.IterationSetup FromJsonObject(JsonElement jsonEleme { if(isDeletedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeleted property of the iterationSetup {id} is null", iterationSetup.Iid); + Logger.Debug("The non-nullabale isDeleted property of the iterationSetup {id} is null", iterationSetup.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.IterationSetup FromJsonObject(JsonElement jsonEleme { if(iterationIidProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale iterationIid property of the iterationSetup {id} is null", iterationSetup.Iid); + Logger.Debug("The non-nullabale iterationIid property of the iterationSetup {id} is null", iterationSetup.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.IterationSetup FromJsonObject(JsonElement jsonEleme { if(iterationNumberProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale iterationNumber property of the iterationSetup {id} is null", iterationSetup.Iid); + Logger.Debug("The non-nullabale iterationNumber property of the iterationSetup {id} is null", iterationSetup.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.IterationSetup FromJsonObject(JsonElement jsonEleme { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the iterationSetup {id} is null", iterationSetup.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the iterationSetup {id} is null", iterationSetup.Iid); } else { @@ -179,7 +179,7 @@ public static CDP4Common.DTO.IterationSetup FromJsonObject(JsonElement jsonEleme { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the iterationSetup {id} is null", iterationSetup.Iid); + Logger.Debug("The non-nullabale thingPreference property of the iterationSetup {id} is null", iterationSetup.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/LinearConversionUnitResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/LinearConversionUnitResolver.cs index 5ec8444b..9cc1bca7 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/LinearConversionUnitResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/LinearConversionUnitResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.LinearConversionUnit FromJsonObject(JsonElement jso { if(conversionFactorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale conversionFactor property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); + Logger.Debug("The non-nullabale conversionFactor property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.LinearConversionUnit FromJsonObject(JsonElement jso { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.LinearConversionUnit FromJsonObject(JsonElement jso { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.LinearConversionUnit FromJsonObject(JsonElement jso { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); + Logger.Debug("The non-nullabale name property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.LinearConversionUnit FromJsonObject(JsonElement jso { if(referenceUnitProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale referenceUnit property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); + Logger.Debug("The non-nullabale referenceUnit property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.LinearConversionUnit FromJsonObject(JsonElement jso { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); + Logger.Debug("The non-nullabale shortName property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); } else { @@ -179,7 +179,7 @@ public static CDP4Common.DTO.LinearConversionUnit FromJsonObject(JsonElement jso { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); + Logger.Debug("The non-nullabale thingPreference property of the linearConversionUnit {id} is null", linearConversionUnit.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/LogEntryChangelogItemResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/LogEntryChangelogItemResolver.cs index 797969a5..b3634847 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/LogEntryChangelogItemResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/LogEntryChangelogItemResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.LogEntryChangelogItem FromJsonObject(JsonElement js { if(affectedItemIidProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale affectedItemIid property of the logEntryChangelogItem {id} is null", logEntryChangelogItem.Iid); + Logger.Debug("The non-nullabale affectedItemIid property of the logEntryChangelogItem {id} is null", logEntryChangelogItem.Iid); } else { @@ -87,7 +87,7 @@ public static CDP4Common.DTO.LogEntryChangelogItem FromJsonObject(JsonElement js { if(changeDescriptionProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale changeDescription property of the logEntryChangelogItem {id} is null", logEntryChangelogItem.Iid); + Logger.Debug("The non-nullabale changeDescription property of the logEntryChangelogItem {id} is null", logEntryChangelogItem.Iid); } else { @@ -99,7 +99,7 @@ public static CDP4Common.DTO.LogEntryChangelogItem FromJsonObject(JsonElement js { if(changelogKindProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale changelogKind property of the logEntryChangelogItem {id} is null", logEntryChangelogItem.Iid); + Logger.Debug("The non-nullabale changelogKind property of the logEntryChangelogItem {id} is null", logEntryChangelogItem.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.LogEntryChangelogItem FromJsonObject(JsonElement js { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the logEntryChangelogItem {id} is null", logEntryChangelogItem.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the logEntryChangelogItem {id} is null", logEntryChangelogItem.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.LogEntryChangelogItem FromJsonObject(JsonElement js { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the logEntryChangelogItem {id} is null", logEntryChangelogItem.Iid); + Logger.Debug("The non-nullabale thingPreference property of the logEntryChangelogItem {id} is null", logEntryChangelogItem.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/LogarithmicScaleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/LogarithmicScaleResolver.cs index 8b3a5e2d..e7e3ecfe 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/LogarithmicScaleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/LogarithmicScaleResolver.cs @@ -99,7 +99,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(exponentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale exponent property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale exponent property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -111,7 +111,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(factorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale factor property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale factor property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(isMaximumInclusiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isMaximumInclusive property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale isMaximumInclusive property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(isMinimumInclusiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isMinimumInclusive property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale isMinimumInclusive property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(logarithmBaseProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale logarithmBase property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale logarithmBase property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(maximumPermissibleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale maximumPermissibleValue property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale maximumPermissibleValue property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -199,7 +199,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(minimumPermissibleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale minimumPermissibleValue property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale minimumPermissibleValue property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -211,7 +211,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -223,7 +223,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale name property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -235,7 +235,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(negativeValueConnotationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale negativeValueConnotation property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale negativeValueConnotation property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -247,7 +247,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(numberSetProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale numberSet property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale numberSet property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -259,7 +259,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(positiveValueConnotationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale positiveValueConnotation property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale positiveValueConnotation property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -271,7 +271,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(referenceQuantityKindProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale referenceQuantityKind property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale referenceQuantityKind property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -291,7 +291,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale shortName property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -303,7 +303,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale thingPreference property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { @@ -315,7 +315,7 @@ public static CDP4Common.DTO.LogarithmicScale FromJsonObject(JsonElement jsonEle { if(unitProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale unit property of the logarithmicScale {id} is null", logarithmicScale.Iid); + Logger.Debug("The non-nullabale unit property of the logarithmicScale {id} is null", logarithmicScale.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/MappingToReferenceScaleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/MappingToReferenceScaleResolver.cs index e9ccb89b..dbb65b2f 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/MappingToReferenceScaleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/MappingToReferenceScaleResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.MappingToReferenceScale FromJsonObject(JsonElement { if(dependentScaleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale dependentScaleValue property of the mappingToReferenceScale {id} is null", mappingToReferenceScale.Iid); + Logger.Debug("The non-nullabale dependentScaleValue property of the mappingToReferenceScale {id} is null", mappingToReferenceScale.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.MappingToReferenceScale FromJsonObject(JsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the mappingToReferenceScale {id} is null", mappingToReferenceScale.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the mappingToReferenceScale {id} is null", mappingToReferenceScale.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.MappingToReferenceScale FromJsonObject(JsonElement { if(referenceScaleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale referenceScaleValue property of the mappingToReferenceScale {id} is null", mappingToReferenceScale.Iid); + Logger.Debug("The non-nullabale referenceScaleValue property of the mappingToReferenceScale {id} is null", mappingToReferenceScale.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.MappingToReferenceScale FromJsonObject(JsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the mappingToReferenceScale {id} is null", mappingToReferenceScale.Iid); + Logger.Debug("The non-nullabale thingPreference property of the mappingToReferenceScale {id} is null", mappingToReferenceScale.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ModelLogEntryResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ModelLogEntryResolver.cs index b094b4c3..46817fda 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ModelLogEntryResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ModelLogEntryResolver.cs @@ -103,7 +103,7 @@ public static CDP4Common.DTO.ModelLogEntry FromJsonObject(JsonElement jsonElemen { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the modelLogEntry {id} is null", modelLogEntry.Iid); + Logger.Debug("The non-nullabale content property of the modelLogEntry {id} is null", modelLogEntry.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.ModelLogEntry FromJsonObject(JsonElement jsonElemen { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the modelLogEntry {id} is null", modelLogEntry.Iid); + Logger.Debug("The non-nullabale createdOn property of the modelLogEntry {id} is null", modelLogEntry.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.ModelLogEntry FromJsonObject(JsonElement jsonElemen { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the modelLogEntry {id} is null", modelLogEntry.Iid); + Logger.Debug("The non-nullabale languageCode property of the modelLogEntry {id} is null", modelLogEntry.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.ModelLogEntry FromJsonObject(JsonElement jsonElemen { if(levelProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale level property of the modelLogEntry {id} is null", modelLogEntry.Iid); + Logger.Debug("The non-nullabale level property of the modelLogEntry {id} is null", modelLogEntry.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.ModelLogEntry FromJsonObject(JsonElement jsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the modelLogEntry {id} is null", modelLogEntry.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the modelLogEntry {id} is null", modelLogEntry.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.ModelLogEntry FromJsonObject(JsonElement jsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the modelLogEntry {id} is null", modelLogEntry.Iid); + Logger.Debug("The non-nullabale thingPreference property of the modelLogEntry {id} is null", modelLogEntry.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ModelReferenceDataLibraryResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ModelReferenceDataLibraryResolver.cs index 30bd10fa..5490153a 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ModelReferenceDataLibraryResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ModelReferenceDataLibraryResolver.cs @@ -152,7 +152,7 @@ public static CDP4Common.DTO.ModelReferenceDataLibrary FromJsonObject(JsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the modelReferenceDataLibrary {id} is null", modelReferenceDataLibrary.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the modelReferenceDataLibrary {id} is null", modelReferenceDataLibrary.Iid); } else { @@ -164,7 +164,7 @@ public static CDP4Common.DTO.ModelReferenceDataLibrary FromJsonObject(JsonElemen { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the modelReferenceDataLibrary {id} is null", modelReferenceDataLibrary.Iid); + Logger.Debug("The non-nullabale name property of the modelReferenceDataLibrary {id} is null", modelReferenceDataLibrary.Iid); } else { @@ -220,7 +220,7 @@ public static CDP4Common.DTO.ModelReferenceDataLibrary FromJsonObject(JsonElemen { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the modelReferenceDataLibrary {id} is null", modelReferenceDataLibrary.Iid); + Logger.Debug("The non-nullabale shortName property of the modelReferenceDataLibrary {id} is null", modelReferenceDataLibrary.Iid); } else { @@ -232,7 +232,7 @@ public static CDP4Common.DTO.ModelReferenceDataLibrary FromJsonObject(JsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the modelReferenceDataLibrary {id} is null", modelReferenceDataLibrary.Iid); + Logger.Debug("The non-nullabale thingPreference property of the modelReferenceDataLibrary {id} is null", modelReferenceDataLibrary.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ModellingThingReferenceResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ModellingThingReferenceResolver.cs index 0be75fb8..9f834b6c 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ModellingThingReferenceResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ModellingThingReferenceResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.ModellingThingReference FromJsonObject(JsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the modellingThingReference {id} is null", modellingThingReference.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the modellingThingReference {id} is null", modellingThingReference.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ModellingThingReference FromJsonObject(JsonElement { if(referencedRevisionNumberProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale referencedRevisionNumber property of the modellingThingReference {id} is null", modellingThingReference.Iid); + Logger.Debug("The non-nullabale referencedRevisionNumber property of the modellingThingReference {id} is null", modellingThingReference.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ModellingThingReference FromJsonObject(JsonElement { if(referencedThingProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale referencedThing property of the modellingThingReference {id} is null", modellingThingReference.Iid); + Logger.Debug("The non-nullabale referencedThing property of the modellingThingReference {id} is null", modellingThingReference.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ModellingThingReference FromJsonObject(JsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the modellingThingReference {id} is null", modellingThingReference.Iid); + Logger.Debug("The non-nullabale thingPreference property of the modellingThingReference {id} is null", modellingThingReference.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/MultiRelationshipResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/MultiRelationshipResolver.cs index bb84b2ff..53831176 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/MultiRelationshipResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/MultiRelationshipResolver.cs @@ -91,7 +91,7 @@ public static CDP4Common.DTO.MultiRelationship FromJsonObject(JsonElement jsonEl { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the multiRelationship {id} is null", multiRelationship.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the multiRelationship {id} is null", multiRelationship.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.MultiRelationship FromJsonObject(JsonElement jsonEl { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the multiRelationship {id} is null", multiRelationship.Iid); + Logger.Debug("The non-nullabale name property of the multiRelationship {id} is null", multiRelationship.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.MultiRelationship FromJsonObject(JsonElement jsonEl { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the multiRelationship {id} is null", multiRelationship.Iid); + Logger.Debug("The non-nullabale owner property of the multiRelationship {id} is null", multiRelationship.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.MultiRelationship FromJsonObject(JsonElement jsonEl { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the multiRelationship {id} is null", multiRelationship.Iid); + Logger.Debug("The non-nullabale thingPreference property of the multiRelationship {id} is null", multiRelationship.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/MultiRelationshipRuleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/MultiRelationshipRuleResolver.cs index f416dd9e..8c980774 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/MultiRelationshipRuleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/MultiRelationshipRuleResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.MultiRelationshipRule FromJsonObject(JsonElement js { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.MultiRelationshipRule FromJsonObject(JsonElement js { if(maxRelatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale maxRelated property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); + Logger.Debug("The non-nullabale maxRelated property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.MultiRelationshipRule FromJsonObject(JsonElement js { if(minRelatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale minRelated property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); + Logger.Debug("The non-nullabale minRelated property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.MultiRelationshipRule FromJsonObject(JsonElement js { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.MultiRelationshipRule FromJsonObject(JsonElement js { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); + Logger.Debug("The non-nullabale name property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.MultiRelationshipRule FromJsonObject(JsonElement js { if(relationshipCategoryProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale relationshipCategory property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); + Logger.Debug("The non-nullabale relationshipCategory property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.MultiRelationshipRule FromJsonObject(JsonElement js { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); + Logger.Debug("The non-nullabale shortName property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); } else { @@ -199,7 +199,7 @@ public static CDP4Common.DTO.MultiRelationshipRule FromJsonObject(JsonElement js { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); + Logger.Debug("The non-nullabale thingPreference property of the multiRelationshipRule {id} is null", multiRelationshipRule.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/NaturalLanguageResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/NaturalLanguageResolver.cs index faf8c2fc..afc4b90e 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/NaturalLanguageResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/NaturalLanguageResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.NaturalLanguage FromJsonObject(JsonElement jsonElem { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the naturalLanguage {id} is null", naturalLanguage.Iid); + Logger.Debug("The non-nullabale languageCode property of the naturalLanguage {id} is null", naturalLanguage.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.NaturalLanguage FromJsonObject(JsonElement jsonElem { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the naturalLanguage {id} is null", naturalLanguage.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the naturalLanguage {id} is null", naturalLanguage.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.NaturalLanguage FromJsonObject(JsonElement jsonElem { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the naturalLanguage {id} is null", naturalLanguage.Iid); + Logger.Debug("The non-nullabale name property of the naturalLanguage {id} is null", naturalLanguage.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.NaturalLanguage FromJsonObject(JsonElement jsonElem { if(nativeNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale nativeName property of the naturalLanguage {id} is null", naturalLanguage.Iid); + Logger.Debug("The non-nullabale nativeName property of the naturalLanguage {id} is null", naturalLanguage.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.NaturalLanguage FromJsonObject(JsonElement jsonElem { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the naturalLanguage {id} is null", naturalLanguage.Iid); + Logger.Debug("The non-nullabale thingPreference property of the naturalLanguage {id} is null", naturalLanguage.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/NestedElementResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/NestedElementResolver.cs index 267e809b..d7eb62e5 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/NestedElementResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/NestedElementResolver.cs @@ -88,7 +88,7 @@ public static CDP4Common.DTO.NestedElement FromJsonObject(JsonElement jsonElemen { if(isVolatileProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isVolatile property of the nestedElement {id} is null", nestedElement.Iid); + Logger.Debug("The non-nullabale isVolatile property of the nestedElement {id} is null", nestedElement.Iid); } else { @@ -100,7 +100,7 @@ public static CDP4Common.DTO.NestedElement FromJsonObject(JsonElement jsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the nestedElement {id} is null", nestedElement.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the nestedElement {id} is null", nestedElement.Iid); } else { @@ -120,7 +120,7 @@ public static CDP4Common.DTO.NestedElement FromJsonObject(JsonElement jsonElemen { if(rootElementProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale rootElement property of the nestedElement {id} is null", nestedElement.Iid); + Logger.Debug("The non-nullabale rootElement property of the nestedElement {id} is null", nestedElement.Iid); } else { @@ -132,7 +132,7 @@ public static CDP4Common.DTO.NestedElement FromJsonObject(JsonElement jsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the nestedElement {id} is null", nestedElement.Iid); + Logger.Debug("The non-nullabale thingPreference property of the nestedElement {id} is null", nestedElement.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/NestedParameterResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/NestedParameterResolver.cs index 2598bdb4..30c14768 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/NestedParameterResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/NestedParameterResolver.cs @@ -79,7 +79,7 @@ public static CDP4Common.DTO.NestedParameter FromJsonObject(JsonElement jsonElem { if(actualValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale actualValue property of the nestedParameter {id} is null", nestedParameter.Iid); + Logger.Debug("The non-nullabale actualValue property of the nestedParameter {id} is null", nestedParameter.Iid); } else { @@ -91,7 +91,7 @@ public static CDP4Common.DTO.NestedParameter FromJsonObject(JsonElement jsonElem { if(associatedParameterProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale associatedParameter property of the nestedParameter {id} is null", nestedParameter.Iid); + Logger.Debug("The non-nullabale associatedParameter property of the nestedParameter {id} is null", nestedParameter.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.NestedParameter FromJsonObject(JsonElement jsonElem { if(formulaProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale formula property of the nestedParameter {id} is null", nestedParameter.Iid); + Logger.Debug("The non-nullabale formula property of the nestedParameter {id} is null", nestedParameter.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.NestedParameter FromJsonObject(JsonElement jsonElem { if(isVolatileProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isVolatile property of the nestedParameter {id} is null", nestedParameter.Iid); + Logger.Debug("The non-nullabale isVolatile property of the nestedParameter {id} is null", nestedParameter.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.NestedParameter FromJsonObject(JsonElement jsonElem { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the nestedParameter {id} is null", nestedParameter.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the nestedParameter {id} is null", nestedParameter.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.NestedParameter FromJsonObject(JsonElement jsonElem { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the nestedParameter {id} is null", nestedParameter.Iid); + Logger.Debug("The non-nullabale owner property of the nestedParameter {id} is null", nestedParameter.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.NestedParameter FromJsonObject(JsonElement jsonElem { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the nestedParameter {id} is null", nestedParameter.Iid); + Logger.Debug("The non-nullabale thingPreference property of the nestedParameter {id} is null", nestedParameter.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/NotExpressionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/NotExpressionResolver.cs index ced4ee8d..185f66df 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/NotExpressionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/NotExpressionResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.NotExpression FromJsonObject(JsonElement jsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the notExpression {id} is null", notExpression.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the notExpression {id} is null", notExpression.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.NotExpression FromJsonObject(JsonElement jsonElemen { if(termProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale term property of the notExpression {id} is null", notExpression.Iid); + Logger.Debug("The non-nullabale term property of the notExpression {id} is null", notExpression.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.NotExpression FromJsonObject(JsonElement jsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the notExpression {id} is null", notExpression.Iid); + Logger.Debug("The non-nullabale thingPreference property of the notExpression {id} is null", notExpression.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/OptionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/OptionResolver.cs index 37f54505..72dd27d0 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/OptionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/OptionResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.Option FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the option {id} is null", option.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the option {id} is null", option.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.Option FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the option {id} is null", option.Iid); + Logger.Debug("The non-nullabale name property of the option {id} is null", option.Iid); } else { @@ -147,7 +147,7 @@ public static CDP4Common.DTO.Option FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the option {id} is null", option.Iid); + Logger.Debug("The non-nullabale shortName property of the option {id} is null", option.Iid); } else { @@ -159,7 +159,7 @@ public static CDP4Common.DTO.Option FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the option {id} is null", option.Iid); + Logger.Debug("The non-nullabale thingPreference property of the option {id} is null", option.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/OrExpressionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/OrExpressionResolver.cs index a6c5e29a..596b989a 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/OrExpressionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/OrExpressionResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.OrExpression FromJsonObject(JsonElement jsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the orExpression {id} is null", orExpression.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the orExpression {id} is null", orExpression.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.OrExpression FromJsonObject(JsonElement jsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the orExpression {id} is null", orExpression.Iid); + Logger.Debug("The non-nullabale thingPreference property of the orExpression {id} is null", orExpression.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/OrdinalScaleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/OrdinalScaleResolver.cs index 28e6d26b..fc3cb214 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/OrdinalScaleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/OrdinalScaleResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(isMaximumInclusiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isMaximumInclusive property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale isMaximumInclusive property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(isMinimumInclusiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isMinimumInclusive property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale isMinimumInclusive property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(maximumPermissibleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale maximumPermissibleValue property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale maximumPermissibleValue property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(minimumPermissibleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale minimumPermissibleValue property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale minimumPermissibleValue property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale name property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -199,7 +199,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(negativeValueConnotationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale negativeValueConnotation property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale negativeValueConnotation property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -211,7 +211,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(numberSetProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale numberSet property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale numberSet property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -223,7 +223,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(positiveValueConnotationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale positiveValueConnotation property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale positiveValueConnotation property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -235,7 +235,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale shortName property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -247,7 +247,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale thingPreference property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -259,7 +259,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(unitProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale unit property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale unit property of the ordinalScale {id} is null", ordinalScale.Iid); } else { @@ -271,7 +271,7 @@ public static CDP4Common.DTO.OrdinalScale FromJsonObject(JsonElement jsonElement { if(useShortNameValuesProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale useShortNameValues property of the ordinalScale {id} is null", ordinalScale.Iid); + Logger.Debug("The non-nullabale useShortNameValues property of the ordinalScale {id} is null", ordinalScale.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/OrganizationResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/OrganizationResolver.cs index 2212bddf..2e50a992 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/OrganizationResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/OrganizationResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.Organization FromJsonObject(JsonElement jsonElement { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the organization {id} is null", organization.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the organization {id} is null", organization.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.Organization FromJsonObject(JsonElement jsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the organization {id} is null", organization.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the organization {id} is null", organization.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.Organization FromJsonObject(JsonElement jsonElement { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the organization {id} is null", organization.Iid); + Logger.Debug("The non-nullabale name property of the organization {id} is null", organization.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.Organization FromJsonObject(JsonElement jsonElement { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the organization {id} is null", organization.Iid); + Logger.Debug("The non-nullabale shortName property of the organization {id} is null", organization.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Organization FromJsonObject(JsonElement jsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the organization {id} is null", organization.Iid); + Logger.Debug("The non-nullabale thingPreference property of the organization {id} is null", organization.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/OrganizationalParticipantResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/OrganizationalParticipantResolver.cs index a477bc0d..560cbfa0 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/OrganizationalParticipantResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/OrganizationalParticipantResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.OrganizationalParticipant FromJsonObject(JsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the organizationalParticipant {id} is null", organizationalParticipant.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the organizationalParticipant {id} is null", organizationalParticipant.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.OrganizationalParticipant FromJsonObject(JsonElemen { if(organizationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale organization property of the organizationalParticipant {id} is null", organizationalParticipant.Iid); + Logger.Debug("The non-nullabale organization property of the organizationalParticipant {id} is null", organizationalParticipant.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.OrganizationalParticipant FromJsonObject(JsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the organizationalParticipant {id} is null", organizationalParticipant.Iid); + Logger.Debug("The non-nullabale thingPreference property of the organizationalParticipant {id} is null", organizationalParticipant.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/OwnedStyleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/OwnedStyleResolver.cs index c4c58cb1..a0c000fb 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/OwnedStyleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/OwnedStyleResolver.cs @@ -143,7 +143,7 @@ public static CDP4Common.DTO.OwnedStyle FromJsonObject(JsonElement jsonElement) { if(fontNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale fontName property of the ownedStyle {id} is null", ownedStyle.Iid); + Logger.Debug("The non-nullabale fontName property of the ownedStyle {id} is null", ownedStyle.Iid); } else { @@ -191,7 +191,7 @@ public static CDP4Common.DTO.OwnedStyle FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the ownedStyle {id} is null", ownedStyle.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the ownedStyle {id} is null", ownedStyle.Iid); } else { @@ -203,7 +203,7 @@ public static CDP4Common.DTO.OwnedStyle FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the ownedStyle {id} is null", ownedStyle.Iid); + Logger.Debug("The non-nullabale name property of the ownedStyle {id} is null", ownedStyle.Iid); } else { @@ -251,7 +251,7 @@ public static CDP4Common.DTO.OwnedStyle FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the ownedStyle {id} is null", ownedStyle.Iid); + Logger.Debug("The non-nullabale thingPreference property of the ownedStyle {id} is null", ownedStyle.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/PageResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/PageResolver.cs index 8e660d4c..80415d1e 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/PageResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/PageResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.Page FromJsonObject(JsonElement jsonElement) { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the page {id} is null", page.Iid); + Logger.Debug("The non-nullabale createdOn property of the page {id} is null", page.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.Page FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the page {id} is null", page.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the page {id} is null", page.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.Page FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the page {id} is null", page.Iid); + Logger.Debug("The non-nullabale name property of the page {id} is null", page.Iid); } else { @@ -132,7 +132,7 @@ public static CDP4Common.DTO.Page FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the page {id} is null", page.Iid); + Logger.Debug("The non-nullabale owner property of the page {id} is null", page.Iid); } else { @@ -144,7 +144,7 @@ public static CDP4Common.DTO.Page FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the page {id} is null", page.Iid); + Logger.Debug("The non-nullabale shortName property of the page {id} is null", page.Iid); } else { @@ -156,7 +156,7 @@ public static CDP4Common.DTO.Page FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the page {id} is null", page.Iid); + Logger.Debug("The non-nullabale thingPreference property of the page {id} is null", page.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterGroupResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterGroupResolver.cs index 464ab4cc..97c0a8da 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterGroupResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterGroupResolver.cs @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ParameterGroup FromJsonObject(JsonElement jsonEleme { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the parameterGroup {id} is null", parameterGroup.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the parameterGroup {id} is null", parameterGroup.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ParameterGroup FromJsonObject(JsonElement jsonEleme { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the parameterGroup {id} is null", parameterGroup.Iid); + Logger.Debug("The non-nullabale name property of the parameterGroup {id} is null", parameterGroup.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ParameterGroup FromJsonObject(JsonElement jsonEleme { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the parameterGroup {id} is null", parameterGroup.Iid); + Logger.Debug("The non-nullabale thingPreference property of the parameterGroup {id} is null", parameterGroup.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterOverrideResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterOverrideResolver.cs index 581450bb..1c54ce87 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterOverrideResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterOverrideResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.ParameterOverride FromJsonObject(JsonElement jsonEl { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the parameterOverride {id} is null", parameterOverride.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the parameterOverride {id} is null", parameterOverride.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ParameterOverride FromJsonObject(JsonElement jsonEl { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the parameterOverride {id} is null", parameterOverride.Iid); + Logger.Debug("The non-nullabale owner property of the parameterOverride {id} is null", parameterOverride.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ParameterOverride FromJsonObject(JsonElement jsonEl { if(parameterProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale parameter property of the parameterOverride {id} is null", parameterOverride.Iid); + Logger.Debug("The non-nullabale parameter property of the parameterOverride {id} is null", parameterOverride.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.ParameterOverride FromJsonObject(JsonElement jsonEl { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the parameterOverride {id} is null", parameterOverride.Iid); + Logger.Debug("The non-nullabale thingPreference property of the parameterOverride {id} is null", parameterOverride.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterOverrideValueSetResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterOverrideValueSetResolver.cs index 24b52b63..431d85fb 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterOverrideValueSetResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterOverrideValueSetResolver.cs @@ -96,7 +96,7 @@ public static CDP4Common.DTO.ParameterOverrideValueSet FromJsonObject(JsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the parameterOverrideValueSet {id} is null", parameterOverrideValueSet.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the parameterOverrideValueSet {id} is null", parameterOverrideValueSet.Iid); } else { @@ -108,7 +108,7 @@ public static CDP4Common.DTO.ParameterOverrideValueSet FromJsonObject(JsonElemen { if(parameterValueSetProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale parameterValueSet property of the parameterOverrideValueSet {id} is null", parameterOverrideValueSet.Iid); + Logger.Debug("The non-nullabale parameterValueSet property of the parameterOverrideValueSet {id} is null", parameterOverrideValueSet.Iid); } else { @@ -128,7 +128,7 @@ public static CDP4Common.DTO.ParameterOverrideValueSet FromJsonObject(JsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the parameterOverrideValueSet {id} is null", parameterOverrideValueSet.Iid); + Logger.Debug("The non-nullabale thingPreference property of the parameterOverrideValueSet {id} is null", parameterOverrideValueSet.Iid); } else { @@ -140,7 +140,7 @@ public static CDP4Common.DTO.ParameterOverrideValueSet FromJsonObject(JsonElemen { if(valueSwitchProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale valueSwitch property of the parameterOverrideValueSet {id} is null", parameterOverrideValueSet.Iid); + Logger.Debug("The non-nullabale valueSwitch property of the parameterOverrideValueSet {id} is null", parameterOverrideValueSet.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterResolver.cs index 8c6f0d9a..f122ceab 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.Parameter FromJsonObject(JsonElement jsonElement) { if(allowDifferentOwnerOfOverrideProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale allowDifferentOwnerOfOverride property of the parameter {id} is null", parameter.Iid); + Logger.Debug("The non-nullabale allowDifferentOwnerOfOverride property of the parameter {id} is null", parameter.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.Parameter FromJsonObject(JsonElement jsonElement) { if(expectsOverrideProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale expectsOverride property of the parameter {id} is null", parameter.Iid); + Logger.Debug("The non-nullabale expectsOverride property of the parameter {id} is null", parameter.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.Parameter FromJsonObject(JsonElement jsonElement) { if(isOptionDependentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isOptionDependent property of the parameter {id} is null", parameter.Iid); + Logger.Debug("The non-nullabale isOptionDependent property of the parameter {id} is null", parameter.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Parameter FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the parameter {id} is null", parameter.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the parameter {id} is null", parameter.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.Parameter FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the parameter {id} is null", parameter.Iid); + Logger.Debug("The non-nullabale owner property of the parameter {id} is null", parameter.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.Parameter FromJsonObject(JsonElement jsonElement) { if(parameterTypeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale parameterType property of the parameter {id} is null", parameter.Iid); + Logger.Debug("The non-nullabale parameterType property of the parameter {id} is null", parameter.Iid); } else { @@ -211,7 +211,7 @@ public static CDP4Common.DTO.Parameter FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the parameter {id} is null", parameter.Iid); + Logger.Debug("The non-nullabale thingPreference property of the parameter {id} is null", parameter.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterSubscriptionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterSubscriptionResolver.cs index 7ed54fe4..98f8d796 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterSubscriptionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterSubscriptionResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.ParameterSubscription FromJsonObject(JsonElement js { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the parameterSubscription {id} is null", parameterSubscription.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the parameterSubscription {id} is null", parameterSubscription.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ParameterSubscription FromJsonObject(JsonElement js { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the parameterSubscription {id} is null", parameterSubscription.Iid); + Logger.Debug("The non-nullabale owner property of the parameterSubscription {id} is null", parameterSubscription.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ParameterSubscription FromJsonObject(JsonElement js { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the parameterSubscription {id} is null", parameterSubscription.Iid); + Logger.Debug("The non-nullabale thingPreference property of the parameterSubscription {id} is null", parameterSubscription.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterSubscriptionValueSetResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterSubscriptionValueSetResolver.cs index 07a28070..e96359ed 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterSubscriptionValueSetResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterSubscriptionValueSetResolver.cs @@ -87,7 +87,7 @@ public static CDP4Common.DTO.ParameterSubscriptionValueSet FromJsonObject(JsonEl { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the parameterSubscriptionValueSet {id} is null", parameterSubscriptionValueSet.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the parameterSubscriptionValueSet {id} is null", parameterSubscriptionValueSet.Iid); } else { @@ -99,7 +99,7 @@ public static CDP4Common.DTO.ParameterSubscriptionValueSet FromJsonObject(JsonEl { if(subscribedValueSetProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale subscribedValueSet property of the parameterSubscriptionValueSet {id} is null", parameterSubscriptionValueSet.Iid); + Logger.Debug("The non-nullabale subscribedValueSet property of the parameterSubscriptionValueSet {id} is null", parameterSubscriptionValueSet.Iid); } else { @@ -111,7 +111,7 @@ public static CDP4Common.DTO.ParameterSubscriptionValueSet FromJsonObject(JsonEl { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the parameterSubscriptionValueSet {id} is null", parameterSubscriptionValueSet.Iid); + Logger.Debug("The non-nullabale thingPreference property of the parameterSubscriptionValueSet {id} is null", parameterSubscriptionValueSet.Iid); } else { @@ -123,7 +123,7 @@ public static CDP4Common.DTO.ParameterSubscriptionValueSet FromJsonObject(JsonEl { if(valueSwitchProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale valueSwitch property of the parameterSubscriptionValueSet {id} is null", parameterSubscriptionValueSet.Iid); + Logger.Debug("The non-nullabale valueSwitch property of the parameterSubscriptionValueSet {id} is null", parameterSubscriptionValueSet.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterTypeComponentResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterTypeComponentResolver.cs index 8223b6a2..46dd2f16 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterTypeComponentResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterTypeComponentResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.ParameterTypeComponent FromJsonObject(JsonElement j { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the parameterTypeComponent {id} is null", parameterTypeComponent.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the parameterTypeComponent {id} is null", parameterTypeComponent.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ParameterTypeComponent FromJsonObject(JsonElement j { if(parameterTypeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale parameterType property of the parameterTypeComponent {id} is null", parameterTypeComponent.Iid); + Logger.Debug("The non-nullabale parameterType property of the parameterTypeComponent {id} is null", parameterTypeComponent.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ParameterTypeComponent FromJsonObject(JsonElement j { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the parameterTypeComponent {id} is null", parameterTypeComponent.Iid); + Logger.Debug("The non-nullabale shortName property of the parameterTypeComponent {id} is null", parameterTypeComponent.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.ParameterTypeComponent FromJsonObject(JsonElement j { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the parameterTypeComponent {id} is null", parameterTypeComponent.Iid); + Logger.Debug("The non-nullabale thingPreference property of the parameterTypeComponent {id} is null", parameterTypeComponent.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterValueSetResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterValueSetResolver.cs index 045a68a1..c90526ee 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterValueSetResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterValueSetResolver.cs @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ParameterValueSet FromJsonObject(JsonElement jsonEl { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the parameterValueSet {id} is null", parameterValueSet.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the parameterValueSet {id} is null", parameterValueSet.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.ParameterValueSet FromJsonObject(JsonElement jsonEl { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the parameterValueSet {id} is null", parameterValueSet.Iid); + Logger.Debug("The non-nullabale thingPreference property of the parameterValueSet {id} is null", parameterValueSet.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.ParameterValueSet FromJsonObject(JsonElement jsonEl { if(valueSwitchProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale valueSwitch property of the parameterValueSet {id} is null", parameterValueSet.Iid); + Logger.Debug("The non-nullabale valueSwitch property of the parameterValueSet {id} is null", parameterValueSet.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterizedCategoryRuleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterizedCategoryRuleResolver.cs index dd07a654..8e2827fd 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterizedCategoryRuleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParameterizedCategoryRuleResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.ParameterizedCategoryRule FromJsonObject(JsonElemen { if(categoryProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale category property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); + Logger.Debug("The non-nullabale category property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ParameterizedCategoryRule FromJsonObject(JsonElemen { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.ParameterizedCategoryRule FromJsonObject(JsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.ParameterizedCategoryRule FromJsonObject(JsonElemen { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); + Logger.Debug("The non-nullabale name property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.ParameterizedCategoryRule FromJsonObject(JsonElemen { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); + Logger.Debug("The non-nullabale shortName property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.ParameterizedCategoryRule FromJsonObject(JsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); + Logger.Debug("The non-nullabale thingPreference property of the parameterizedCategoryRule {id} is null", parameterizedCategoryRule.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParametricConstraintResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParametricConstraintResolver.cs index 0a2167b1..f2d354a8 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParametricConstraintResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParametricConstraintResolver.cs @@ -91,7 +91,7 @@ public static CDP4Common.DTO.ParametricConstraint FromJsonObject(JsonElement jso { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the parametricConstraint {id} is null", parametricConstraint.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the parametricConstraint {id} is null", parametricConstraint.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.ParametricConstraint FromJsonObject(JsonElement jso { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the parametricConstraint {id} is null", parametricConstraint.Iid); + Logger.Debug("The non-nullabale thingPreference property of the parametricConstraint {id} is null", parametricConstraint.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantPermissionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantPermissionResolver.cs index c2339f65..fb6c00c0 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantPermissionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantPermissionResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.ParticipantPermission FromJsonObject(JsonElement js { if(accessRightProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale accessRight property of the participantPermission {id} is null", participantPermission.Iid); + Logger.Debug("The non-nullabale accessRight property of the participantPermission {id} is null", participantPermission.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ParticipantPermission FromJsonObject(JsonElement js { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the participantPermission {id} is null", participantPermission.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the participantPermission {id} is null", participantPermission.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ParticipantPermission FromJsonObject(JsonElement js { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the participantPermission {id} is null", participantPermission.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the participantPermission {id} is null", participantPermission.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ParticipantPermission FromJsonObject(JsonElement js { if(objectClassProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale objectClass property of the participantPermission {id} is null", participantPermission.Iid); + Logger.Debug("The non-nullabale objectClass property of the participantPermission {id} is null", participantPermission.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.ParticipantPermission FromJsonObject(JsonElement js { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the participantPermission {id} is null", participantPermission.Iid); + Logger.Debug("The non-nullabale thingPreference property of the participantPermission {id} is null", participantPermission.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantResolver.cs index ae2e9739..0748cf6a 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantResolver.cs @@ -91,7 +91,7 @@ public static CDP4Common.DTO.Participant FromJsonObject(JsonElement jsonElement) { if(isActiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isActive property of the participant {id} is null", participant.Iid); + Logger.Debug("The non-nullabale isActive property of the participant {id} is null", participant.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.Participant FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the participant {id} is null", participant.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the participant {id} is null", participant.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.Participant FromJsonObject(JsonElement jsonElement) { if(personProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale person property of the participant {id} is null", participant.Iid); + Logger.Debug("The non-nullabale person property of the participant {id} is null", participant.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.Participant FromJsonObject(JsonElement jsonElement) { if(roleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale role property of the participant {id} is null", participant.Iid); + Logger.Debug("The non-nullabale role property of the participant {id} is null", participant.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.Participant FromJsonObject(JsonElement jsonElement) { if(selectedDomainProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale selectedDomain property of the participant {id} is null", participant.Iid); + Logger.Debug("The non-nullabale selectedDomain property of the participant {id} is null", participant.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.Participant FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the participant {id} is null", participant.Iid); + Logger.Debug("The non-nullabale thingPreference property of the participant {id} is null", participant.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantRoleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantRoleResolver.cs index dc98a81e..d9f821a4 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantRoleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ParticipantRoleResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ParticipantRole FromJsonObject(JsonElement jsonElem { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the participantRole {id} is null", participantRole.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the participantRole {id} is null", participantRole.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ParticipantRole FromJsonObject(JsonElement jsonElem { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the participantRole {id} is null", participantRole.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the participantRole {id} is null", participantRole.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.ParticipantRole FromJsonObject(JsonElement jsonElem { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the participantRole {id} is null", participantRole.Iid); + Logger.Debug("The non-nullabale name property of the participantRole {id} is null", participantRole.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.ParticipantRole FromJsonObject(JsonElement jsonElem { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the participantRole {id} is null", participantRole.Iid); + Logger.Debug("The non-nullabale shortName property of the participantRole {id} is null", participantRole.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.ParticipantRole FromJsonObject(JsonElement jsonElem { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the participantRole {id} is null", participantRole.Iid); + Logger.Debug("The non-nullabale thingPreference property of the participantRole {id} is null", participantRole.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonPermissionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonPermissionResolver.cs index 4319167f..e9bf0582 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonPermissionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonPermissionResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.PersonPermission FromJsonObject(JsonElement jsonEle { if(accessRightProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale accessRight property of the personPermission {id} is null", personPermission.Iid); + Logger.Debug("The non-nullabale accessRight property of the personPermission {id} is null", personPermission.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.PersonPermission FromJsonObject(JsonElement jsonEle { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the personPermission {id} is null", personPermission.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the personPermission {id} is null", personPermission.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.PersonPermission FromJsonObject(JsonElement jsonEle { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the personPermission {id} is null", personPermission.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the personPermission {id} is null", personPermission.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.PersonPermission FromJsonObject(JsonElement jsonEle { if(objectClassProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale objectClass property of the personPermission {id} is null", personPermission.Iid); + Logger.Debug("The non-nullabale objectClass property of the personPermission {id} is null", personPermission.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.PersonPermission FromJsonObject(JsonElement jsonEle { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the personPermission {id} is null", personPermission.Iid); + Logger.Debug("The non-nullabale thingPreference property of the personPermission {id} is null", personPermission.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonResolver.cs index 286a55dd..e5c3c1b4 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonResolver.cs @@ -127,7 +127,7 @@ public static CDP4Common.DTO.Person FromJsonObject(JsonElement jsonElement) { if(givenNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale givenName property of the person {id} is null", person.Iid); + Logger.Debug("The non-nullabale givenName property of the person {id} is null", person.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.Person FromJsonObject(JsonElement jsonElement) { if(isActiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isActive property of the person {id} is null", person.Iid); + Logger.Debug("The non-nullabale isActive property of the person {id} is null", person.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.Person FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the person {id} is null", person.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the person {id} is null", person.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.Person FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the person {id} is null", person.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the person {id} is null", person.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.Person FromJsonObject(JsonElement jsonElement) { if(organizationalUnitProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale organizationalUnit property of the person {id} is null", person.Iid); + Logger.Debug("The non-nullabale organizationalUnit property of the person {id} is null", person.Iid); } else { @@ -199,7 +199,7 @@ public static CDP4Common.DTO.Person FromJsonObject(JsonElement jsonElement) { if(passwordProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale password property of the person {id} is null", person.Iid); + Logger.Debug("The non-nullabale password property of the person {id} is null", person.Iid); } else { @@ -223,7 +223,7 @@ public static CDP4Common.DTO.Person FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the person {id} is null", person.Iid); + Logger.Debug("The non-nullabale shortName property of the person {id} is null", person.Iid); } else { @@ -235,7 +235,7 @@ public static CDP4Common.DTO.Person FromJsonObject(JsonElement jsonElement) { if(surnameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale surname property of the person {id} is null", person.Iid); + Logger.Debug("The non-nullabale surname property of the person {id} is null", person.Iid); } else { @@ -255,7 +255,7 @@ public static CDP4Common.DTO.Person FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the person {id} is null", person.Iid); + Logger.Debug("The non-nullabale thingPreference property of the person {id} is null", person.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonRoleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonRoleResolver.cs index 41661b8b..0b6afb33 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonRoleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/PersonRoleResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.PersonRole FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the personRole {id} is null", personRole.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the personRole {id} is null", personRole.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.PersonRole FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the personRole {id} is null", personRole.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the personRole {id} is null", personRole.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.PersonRole FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the personRole {id} is null", personRole.Iid); + Logger.Debug("The non-nullabale name property of the personRole {id} is null", personRole.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.PersonRole FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the personRole {id} is null", personRole.Iid); + Logger.Debug("The non-nullabale shortName property of the personRole {id} is null", personRole.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.PersonRole FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the personRole {id} is null", personRole.Iid); + Logger.Debug("The non-nullabale thingPreference property of the personRole {id} is null", personRole.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/PointResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/PointResolver.cs index cbe6fc2a..fb36ae54 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/PointResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/PointResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.Point FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the point {id} is null", point.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the point {id} is null", point.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.Point FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the point {id} is null", point.Iid); + Logger.Debug("The non-nullabale name property of the point {id} is null", point.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.Point FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the point {id} is null", point.Iid); + Logger.Debug("The non-nullabale thingPreference property of the point {id} is null", point.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.Point FromJsonObject(JsonElement jsonElement) { if(xProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale x property of the point {id} is null", point.Iid); + Logger.Debug("The non-nullabale x property of the point {id} is null", point.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Point FromJsonObject(JsonElement jsonElement) { if(yProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale y property of the point {id} is null", point.Iid); + Logger.Debug("The non-nullabale y property of the point {id} is null", point.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/PossibleFiniteStateListResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/PossibleFiniteStateListResolver.cs index e512c0dc..3f9da6d3 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/PossibleFiniteStateListResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/PossibleFiniteStateListResolver.cs @@ -127,7 +127,7 @@ public static CDP4Common.DTO.PossibleFiniteStateList FromJsonObject(JsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the possibleFiniteStateList {id} is null", possibleFiniteStateList.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the possibleFiniteStateList {id} is null", possibleFiniteStateList.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.PossibleFiniteStateList FromJsonObject(JsonElement { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the possibleFiniteStateList {id} is null", possibleFiniteStateList.Iid); + Logger.Debug("The non-nullabale name property of the possibleFiniteStateList {id} is null", possibleFiniteStateList.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.PossibleFiniteStateList FromJsonObject(JsonElement { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the possibleFiniteStateList {id} is null", possibleFiniteStateList.Iid); + Logger.Debug("The non-nullabale owner property of the possibleFiniteStateList {id} is null", possibleFiniteStateList.Iid); } else { @@ -168,7 +168,7 @@ public static CDP4Common.DTO.PossibleFiniteStateList FromJsonObject(JsonElement { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the possibleFiniteStateList {id} is null", possibleFiniteStateList.Iid); + Logger.Debug("The non-nullabale shortName property of the possibleFiniteStateList {id} is null", possibleFiniteStateList.Iid); } else { @@ -180,7 +180,7 @@ public static CDP4Common.DTO.PossibleFiniteStateList FromJsonObject(JsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the possibleFiniteStateList {id} is null", possibleFiniteStateList.Iid); + Logger.Debug("The non-nullabale thingPreference property of the possibleFiniteStateList {id} is null", possibleFiniteStateList.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/PossibleFiniteStateResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/PossibleFiniteStateResolver.cs index 11535ae6..03d5087d 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/PossibleFiniteStateResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/PossibleFiniteStateResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.PossibleFiniteState FromJsonObject(JsonElement json { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the possibleFiniteState {id} is null", possibleFiniteState.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the possibleFiniteState {id} is null", possibleFiniteState.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.PossibleFiniteState FromJsonObject(JsonElement json { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the possibleFiniteState {id} is null", possibleFiniteState.Iid); + Logger.Debug("The non-nullabale name property of the possibleFiniteState {id} is null", possibleFiniteState.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.PossibleFiniteState FromJsonObject(JsonElement json { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the possibleFiniteState {id} is null", possibleFiniteState.Iid); + Logger.Debug("The non-nullabale shortName property of the possibleFiniteState {id} is null", possibleFiniteState.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.PossibleFiniteState FromJsonObject(JsonElement json { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the possibleFiniteState {id} is null", possibleFiniteState.Iid); + Logger.Debug("The non-nullabale thingPreference property of the possibleFiniteState {id} is null", possibleFiniteState.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/PrefixedUnitResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/PrefixedUnitResolver.cs index 839c1402..e5864560 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/PrefixedUnitResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/PrefixedUnitResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.PrefixedUnit FromJsonObject(JsonElement jsonElement { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the prefixedUnit {id} is null", prefixedUnit.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the prefixedUnit {id} is null", prefixedUnit.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.PrefixedUnit FromJsonObject(JsonElement jsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the prefixedUnit {id} is null", prefixedUnit.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the prefixedUnit {id} is null", prefixedUnit.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.PrefixedUnit FromJsonObject(JsonElement jsonElement { if(prefixProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale prefix property of the prefixedUnit {id} is null", prefixedUnit.Iid); + Logger.Debug("The non-nullabale prefix property of the prefixedUnit {id} is null", prefixedUnit.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.PrefixedUnit FromJsonObject(JsonElement jsonElement { if(referenceUnitProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale referenceUnit property of the prefixedUnit {id} is null", prefixedUnit.Iid); + Logger.Debug("The non-nullabale referenceUnit property of the prefixedUnit {id} is null", prefixedUnit.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.PrefixedUnit FromJsonObject(JsonElement jsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the prefixedUnit {id} is null", prefixedUnit.Iid); + Logger.Debug("The non-nullabale thingPreference property of the prefixedUnit {id} is null", prefixedUnit.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/PublicationResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/PublicationResolver.cs index d72f4da5..8928ca91 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/PublicationResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/PublicationResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.Publication FromJsonObject(JsonElement jsonElement) { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the publication {id} is null", publication.Iid); + Logger.Debug("The non-nullabale createdOn property of the publication {id} is null", publication.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.Publication FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the publication {id} is null", publication.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the publication {id} is null", publication.Iid); } else { @@ -123,7 +123,7 @@ public static CDP4Common.DTO.Publication FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the publication {id} is null", publication.Iid); + Logger.Debug("The non-nullabale thingPreference property of the publication {id} is null", publication.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/QuantityKindFactorResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/QuantityKindFactorResolver.cs index 08926379..ce4a9391 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/QuantityKindFactorResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/QuantityKindFactorResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.QuantityKindFactor FromJsonObject(JsonElement jsonE { if(exponentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale exponent property of the quantityKindFactor {id} is null", quantityKindFactor.Iid); + Logger.Debug("The non-nullabale exponent property of the quantityKindFactor {id} is null", quantityKindFactor.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.QuantityKindFactor FromJsonObject(JsonElement jsonE { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the quantityKindFactor {id} is null", quantityKindFactor.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the quantityKindFactor {id} is null", quantityKindFactor.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.QuantityKindFactor FromJsonObject(JsonElement jsonE { if(quantityKindProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale quantityKind property of the quantityKindFactor {id} is null", quantityKindFactor.Iid); + Logger.Debug("The non-nullabale quantityKind property of the quantityKindFactor {id} is null", quantityKindFactor.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.QuantityKindFactor FromJsonObject(JsonElement jsonE { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the quantityKindFactor {id} is null", quantityKindFactor.Iid); + Logger.Debug("The non-nullabale thingPreference property of the quantityKindFactor {id} is null", quantityKindFactor.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/RatioScaleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/RatioScaleResolver.cs index 7cf7008c..3f4d494d 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/RatioScaleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/RatioScaleResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(isMaximumInclusiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isMaximumInclusive property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale isMaximumInclusive property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(isMinimumInclusiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isMinimumInclusive property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale isMinimumInclusive property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(maximumPermissibleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale maximumPermissibleValue property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale maximumPermissibleValue property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(minimumPermissibleValueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale minimumPermissibleValue property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale minimumPermissibleValue property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale name property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -199,7 +199,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(negativeValueConnotationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale negativeValueConnotation property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale negativeValueConnotation property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -211,7 +211,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(numberSetProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale numberSet property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale numberSet property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -223,7 +223,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(positiveValueConnotationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale positiveValueConnotation property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale positiveValueConnotation property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -235,7 +235,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale shortName property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -247,7 +247,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale thingPreference property of the ratioScale {id} is null", ratioScale.Iid); } else { @@ -259,7 +259,7 @@ public static CDP4Common.DTO.RatioScale FromJsonObject(JsonElement jsonElement) { if(unitProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale unit property of the ratioScale {id} is null", ratioScale.Iid); + Logger.Debug("The non-nullabale unit property of the ratioScale {id} is null", ratioScale.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ReferenceSourceResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ReferenceSourceResolver.cs index b32c0805..4590d1a6 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ReferenceSourceResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ReferenceSourceResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.ReferenceSource FromJsonObject(JsonElement jsonElem { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the referenceSource {id} is null", referenceSource.Iid); + Logger.Debug("The non-nullabale author property of the referenceSource {id} is null", referenceSource.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.ReferenceSource FromJsonObject(JsonElement jsonElem { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the referenceSource {id} is null", referenceSource.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the referenceSource {id} is null", referenceSource.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.ReferenceSource FromJsonObject(JsonElement jsonElem { if(languageProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale language property of the referenceSource {id} is null", referenceSource.Iid); + Logger.Debug("The non-nullabale language property of the referenceSource {id} is null", referenceSource.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.ReferenceSource FromJsonObject(JsonElement jsonElem { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the referenceSource {id} is null", referenceSource.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the referenceSource {id} is null", referenceSource.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.ReferenceSource FromJsonObject(JsonElement jsonElem { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the referenceSource {id} is null", referenceSource.Iid); + Logger.Debug("The non-nullabale name property of the referenceSource {id} is null", referenceSource.Iid); } else { @@ -211,7 +211,7 @@ public static CDP4Common.DTO.ReferenceSource FromJsonObject(JsonElement jsonElem { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the referenceSource {id} is null", referenceSource.Iid); + Logger.Debug("The non-nullabale shortName property of the referenceSource {id} is null", referenceSource.Iid); } else { @@ -223,7 +223,7 @@ public static CDP4Common.DTO.ReferenceSource FromJsonObject(JsonElement jsonElem { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the referenceSource {id} is null", referenceSource.Iid); + Logger.Debug("The non-nullabale thingPreference property of the referenceSource {id} is null", referenceSource.Iid); } else { @@ -247,7 +247,7 @@ public static CDP4Common.DTO.ReferenceSource FromJsonObject(JsonElement jsonElem { if(versionIdentifierProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale versionIdentifier property of the referenceSource {id} is null", referenceSource.Iid); + Logger.Debug("The non-nullabale versionIdentifier property of the referenceSource {id} is null", referenceSource.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ReferencerRuleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ReferencerRuleResolver.cs index fc0f5667..c965a9f7 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ReferencerRuleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ReferencerRuleResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ReferencerRule FromJsonObject(JsonElement jsonEleme { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the referencerRule {id} is null", referencerRule.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the referencerRule {id} is null", referencerRule.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ReferencerRule FromJsonObject(JsonElement jsonEleme { if(maxReferencedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale maxReferenced property of the referencerRule {id} is null", referencerRule.Iid); + Logger.Debug("The non-nullabale maxReferenced property of the referencerRule {id} is null", referencerRule.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.ReferencerRule FromJsonObject(JsonElement jsonEleme { if(minReferencedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale minReferenced property of the referencerRule {id} is null", referencerRule.Iid); + Logger.Debug("The non-nullabale minReferenced property of the referencerRule {id} is null", referencerRule.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.ReferencerRule FromJsonObject(JsonElement jsonEleme { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the referencerRule {id} is null", referencerRule.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the referencerRule {id} is null", referencerRule.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.ReferencerRule FromJsonObject(JsonElement jsonEleme { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the referencerRule {id} is null", referencerRule.Iid); + Logger.Debug("The non-nullabale name property of the referencerRule {id} is null", referencerRule.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.ReferencerRule FromJsonObject(JsonElement jsonEleme { if(referencingCategoryProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale referencingCategory property of the referencerRule {id} is null", referencerRule.Iid); + Logger.Debug("The non-nullabale referencingCategory property of the referencerRule {id} is null", referencerRule.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.ReferencerRule FromJsonObject(JsonElement jsonEleme { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the referencerRule {id} is null", referencerRule.Iid); + Logger.Debug("The non-nullabale shortName property of the referencerRule {id} is null", referencerRule.Iid); } else { @@ -199,7 +199,7 @@ public static CDP4Common.DTO.ReferencerRule FromJsonObject(JsonElement jsonEleme { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the referencerRule {id} is null", referencerRule.Iid); + Logger.Debug("The non-nullabale thingPreference property of the referencerRule {id} is null", referencerRule.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/RelationalExpressionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/RelationalExpressionResolver.cs index ca549cad..77c39268 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/RelationalExpressionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/RelationalExpressionResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.RelationalExpression FromJsonObject(JsonElement jso { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the relationalExpression {id} is null", relationalExpression.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the relationalExpression {id} is null", relationalExpression.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.RelationalExpression FromJsonObject(JsonElement jso { if(parameterTypeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale parameterType property of the relationalExpression {id} is null", relationalExpression.Iid); + Logger.Debug("The non-nullabale parameterType property of the relationalExpression {id} is null", relationalExpression.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.RelationalExpression FromJsonObject(JsonElement jso { if(relationalOperatorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale relationalOperator property of the relationalExpression {id} is null", relationalExpression.Iid); + Logger.Debug("The non-nullabale relationalOperator property of the relationalExpression {id} is null", relationalExpression.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.RelationalExpression FromJsonObject(JsonElement jso { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the relationalExpression {id} is null", relationalExpression.Iid); + Logger.Debug("The non-nullabale thingPreference property of the relationalExpression {id} is null", relationalExpression.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/RelationshipParameterValueResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/RelationshipParameterValueResolver.cs index 65c5f923..8437ea8a 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/RelationshipParameterValueResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/RelationshipParameterValueResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.RelationshipParameterValue FromJsonObject(JsonEleme { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the relationshipParameterValue {id} is null", relationshipParameterValue.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the relationshipParameterValue {id} is null", relationshipParameterValue.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.RelationshipParameterValue FromJsonObject(JsonEleme { if(parameterTypeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale parameterType property of the relationshipParameterValue {id} is null", relationshipParameterValue.Iid); + Logger.Debug("The non-nullabale parameterType property of the relationshipParameterValue {id} is null", relationshipParameterValue.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.RelationshipParameterValue FromJsonObject(JsonEleme { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the relationshipParameterValue {id} is null", relationshipParameterValue.Iid); + Logger.Debug("The non-nullabale thingPreference property of the relationshipParameterValue {id} is null", relationshipParameterValue.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequestForDeviationResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequestForDeviationResolver.cs index e3f87ec3..f4bd8841 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequestForDeviationResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequestForDeviationResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.RequestForDeviation FromJsonObject(JsonElement json { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the requestForDeviation {id} is null", requestForDeviation.Iid); + Logger.Debug("The non-nullabale author property of the requestForDeviation {id} is null", requestForDeviation.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.RequestForDeviation FromJsonObject(JsonElement json { if(classificationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale classification property of the requestForDeviation {id} is null", requestForDeviation.Iid); + Logger.Debug("The non-nullabale classification property of the requestForDeviation {id} is null", requestForDeviation.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.RequestForDeviation FromJsonObject(JsonElement json { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the requestForDeviation {id} is null", requestForDeviation.Iid); + Logger.Debug("The non-nullabale content property of the requestForDeviation {id} is null", requestForDeviation.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.RequestForDeviation FromJsonObject(JsonElement json { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the requestForDeviation {id} is null", requestForDeviation.Iid); + Logger.Debug("The non-nullabale createdOn property of the requestForDeviation {id} is null", requestForDeviation.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.RequestForDeviation FromJsonObject(JsonElement json { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the requestForDeviation {id} is null", requestForDeviation.Iid); + Logger.Debug("The non-nullabale languageCode property of the requestForDeviation {id} is null", requestForDeviation.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.RequestForDeviation FromJsonObject(JsonElement json { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the requestForDeviation {id} is null", requestForDeviation.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the requestForDeviation {id} is null", requestForDeviation.Iid); } else { @@ -179,7 +179,7 @@ public static CDP4Common.DTO.RequestForDeviation FromJsonObject(JsonElement json { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the requestForDeviation {id} is null", requestForDeviation.Iid); + Logger.Debug("The non-nullabale owner property of the requestForDeviation {id} is null", requestForDeviation.Iid); } else { @@ -211,7 +211,7 @@ public static CDP4Common.DTO.RequestForDeviation FromJsonObject(JsonElement json { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the requestForDeviation {id} is null", requestForDeviation.Iid); + Logger.Debug("The non-nullabale shortName property of the requestForDeviation {id} is null", requestForDeviation.Iid); } else { @@ -231,7 +231,7 @@ public static CDP4Common.DTO.RequestForDeviation FromJsonObject(JsonElement json { if(statusProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale status property of the requestForDeviation {id} is null", requestForDeviation.Iid); + Logger.Debug("The non-nullabale status property of the requestForDeviation {id} is null", requestForDeviation.Iid); } else { @@ -243,7 +243,7 @@ public static CDP4Common.DTO.RequestForDeviation FromJsonObject(JsonElement json { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the requestForDeviation {id} is null", requestForDeviation.Iid); + Logger.Debug("The non-nullabale thingPreference property of the requestForDeviation {id} is null", requestForDeviation.Iid); } else { @@ -255,7 +255,7 @@ public static CDP4Common.DTO.RequestForDeviation FromJsonObject(JsonElement json { if(titleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale title property of the requestForDeviation {id} is null", requestForDeviation.Iid); + Logger.Debug("The non-nullabale title property of the requestForDeviation {id} is null", requestForDeviation.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequestForWaiverResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequestForWaiverResolver.cs index a56451c6..e957a504 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequestForWaiverResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequestForWaiverResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.RequestForWaiver FromJsonObject(JsonElement jsonEle { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the requestForWaiver {id} is null", requestForWaiver.Iid); + Logger.Debug("The non-nullabale author property of the requestForWaiver {id} is null", requestForWaiver.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.RequestForWaiver FromJsonObject(JsonElement jsonEle { if(classificationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale classification property of the requestForWaiver {id} is null", requestForWaiver.Iid); + Logger.Debug("The non-nullabale classification property of the requestForWaiver {id} is null", requestForWaiver.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.RequestForWaiver FromJsonObject(JsonElement jsonEle { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the requestForWaiver {id} is null", requestForWaiver.Iid); + Logger.Debug("The non-nullabale content property of the requestForWaiver {id} is null", requestForWaiver.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.RequestForWaiver FromJsonObject(JsonElement jsonEle { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the requestForWaiver {id} is null", requestForWaiver.Iid); + Logger.Debug("The non-nullabale createdOn property of the requestForWaiver {id} is null", requestForWaiver.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.RequestForWaiver FromJsonObject(JsonElement jsonEle { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the requestForWaiver {id} is null", requestForWaiver.Iid); + Logger.Debug("The non-nullabale languageCode property of the requestForWaiver {id} is null", requestForWaiver.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.RequestForWaiver FromJsonObject(JsonElement jsonEle { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the requestForWaiver {id} is null", requestForWaiver.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the requestForWaiver {id} is null", requestForWaiver.Iid); } else { @@ -179,7 +179,7 @@ public static CDP4Common.DTO.RequestForWaiver FromJsonObject(JsonElement jsonEle { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the requestForWaiver {id} is null", requestForWaiver.Iid); + Logger.Debug("The non-nullabale owner property of the requestForWaiver {id} is null", requestForWaiver.Iid); } else { @@ -211,7 +211,7 @@ public static CDP4Common.DTO.RequestForWaiver FromJsonObject(JsonElement jsonEle { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the requestForWaiver {id} is null", requestForWaiver.Iid); + Logger.Debug("The non-nullabale shortName property of the requestForWaiver {id} is null", requestForWaiver.Iid); } else { @@ -231,7 +231,7 @@ public static CDP4Common.DTO.RequestForWaiver FromJsonObject(JsonElement jsonEle { if(statusProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale status property of the requestForWaiver {id} is null", requestForWaiver.Iid); + Logger.Debug("The non-nullabale status property of the requestForWaiver {id} is null", requestForWaiver.Iid); } else { @@ -243,7 +243,7 @@ public static CDP4Common.DTO.RequestForWaiver FromJsonObject(JsonElement jsonEle { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the requestForWaiver {id} is null", requestForWaiver.Iid); + Logger.Debug("The non-nullabale thingPreference property of the requestForWaiver {id} is null", requestForWaiver.Iid); } else { @@ -255,7 +255,7 @@ public static CDP4Common.DTO.RequestForWaiver FromJsonObject(JsonElement jsonEle { if(titleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale title property of the requestForWaiver {id} is null", requestForWaiver.Iid); + Logger.Debug("The non-nullabale title property of the requestForWaiver {id} is null", requestForWaiver.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementResolver.cs index 2d7adbcd..5fde343c 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementResolver.cs @@ -127,7 +127,7 @@ public static CDP4Common.DTO.Requirement FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the requirement {id} is null", requirement.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the requirement {id} is null", requirement.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.Requirement FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the requirement {id} is null", requirement.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the requirement {id} is null", requirement.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.Requirement FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the requirement {id} is null", requirement.Iid); + Logger.Debug("The non-nullabale name property of the requirement {id} is null", requirement.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.Requirement FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the requirement {id} is null", requirement.Iid); + Logger.Debug("The non-nullabale owner property of the requirement {id} is null", requirement.Iid); } else { @@ -188,7 +188,7 @@ public static CDP4Common.DTO.Requirement FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the requirement {id} is null", requirement.Iid); + Logger.Debug("The non-nullabale shortName property of the requirement {id} is null", requirement.Iid); } else { @@ -200,7 +200,7 @@ public static CDP4Common.DTO.Requirement FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the requirement {id} is null", requirement.Iid); + Logger.Debug("The non-nullabale thingPreference property of the requirement {id} is null", requirement.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsContainerParameterValueResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsContainerParameterValueResolver.cs index 4fbdf07a..634d5fbf 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsContainerParameterValueResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsContainerParameterValueResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.RequirementsContainerParameterValue FromJsonObject( { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the requirementsContainerParameterValue {id} is null", requirementsContainerParameterValue.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the requirementsContainerParameterValue {id} is null", requirementsContainerParameterValue.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.RequirementsContainerParameterValue FromJsonObject( { if(parameterTypeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale parameterType property of the requirementsContainerParameterValue {id} is null", requirementsContainerParameterValue.Iid); + Logger.Debug("The non-nullabale parameterType property of the requirementsContainerParameterValue {id} is null", requirementsContainerParameterValue.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.RequirementsContainerParameterValue FromJsonObject( { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the requirementsContainerParameterValue {id} is null", requirementsContainerParameterValue.Iid); + Logger.Debug("The non-nullabale thingPreference property of the requirementsContainerParameterValue {id} is null", requirementsContainerParameterValue.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsGroupResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsGroupResolver.cs index 1439abe7..b6e4218e 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsGroupResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsGroupResolver.cs @@ -123,7 +123,7 @@ public static CDP4Common.DTO.RequirementsGroup FromJsonObject(JsonElement jsonEl { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the requirementsGroup {id} is null", requirementsGroup.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the requirementsGroup {id} is null", requirementsGroup.Iid); } else { @@ -135,7 +135,7 @@ public static CDP4Common.DTO.RequirementsGroup FromJsonObject(JsonElement jsonEl { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the requirementsGroup {id} is null", requirementsGroup.Iid); + Logger.Debug("The non-nullabale name property of the requirementsGroup {id} is null", requirementsGroup.Iid); } else { @@ -147,7 +147,7 @@ public static CDP4Common.DTO.RequirementsGroup FromJsonObject(JsonElement jsonEl { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the requirementsGroup {id} is null", requirementsGroup.Iid); + Logger.Debug("The non-nullabale owner property of the requirementsGroup {id} is null", requirementsGroup.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.RequirementsGroup FromJsonObject(JsonElement jsonEl { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the requirementsGroup {id} is null", requirementsGroup.Iid); + Logger.Debug("The non-nullabale shortName property of the requirementsGroup {id} is null", requirementsGroup.Iid); } else { @@ -179,7 +179,7 @@ public static CDP4Common.DTO.RequirementsGroup FromJsonObject(JsonElement jsonEl { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the requirementsGroup {id} is null", requirementsGroup.Iid); + Logger.Debug("The non-nullabale thingPreference property of the requirementsGroup {id} is null", requirementsGroup.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsSpecificationResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsSpecificationResolver.cs index c6cb5b0c..42302611 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsSpecificationResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/RequirementsSpecificationResolver.cs @@ -123,7 +123,7 @@ public static CDP4Common.DTO.RequirementsSpecification FromJsonObject(JsonElemen { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); } else { @@ -135,7 +135,7 @@ public static CDP4Common.DTO.RequirementsSpecification FromJsonObject(JsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); } else { @@ -147,7 +147,7 @@ public static CDP4Common.DTO.RequirementsSpecification FromJsonObject(JsonElemen { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); + Logger.Debug("The non-nullabale name property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); } else { @@ -159,7 +159,7 @@ public static CDP4Common.DTO.RequirementsSpecification FromJsonObject(JsonElemen { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); + Logger.Debug("The non-nullabale owner property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.RequirementsSpecification FromJsonObject(JsonElemen { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); + Logger.Debug("The non-nullabale shortName property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); } else { @@ -199,7 +199,7 @@ public static CDP4Common.DTO.RequirementsSpecification FromJsonObject(JsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); + Logger.Debug("The non-nullabale thingPreference property of the requirementsSpecification {id} is null", requirementsSpecification.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ReviewItemDiscrepancyResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ReviewItemDiscrepancyResolver.cs index 163e5085..ad287307 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ReviewItemDiscrepancyResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ReviewItemDiscrepancyResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.ReviewItemDiscrepancy FromJsonObject(JsonElement js { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); + Logger.Debug("The non-nullabale author property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ReviewItemDiscrepancy FromJsonObject(JsonElement js { if(classificationProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale classification property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); + Logger.Debug("The non-nullabale classification property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ReviewItemDiscrepancy FromJsonObject(JsonElement js { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); + Logger.Debug("The non-nullabale content property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ReviewItemDiscrepancy FromJsonObject(JsonElement js { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); + Logger.Debug("The non-nullabale createdOn property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.ReviewItemDiscrepancy FromJsonObject(JsonElement js { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); + Logger.Debug("The non-nullabale languageCode property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.ReviewItemDiscrepancy FromJsonObject(JsonElement js { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); } else { @@ -179,7 +179,7 @@ public static CDP4Common.DTO.ReviewItemDiscrepancy FromJsonObject(JsonElement js { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); + Logger.Debug("The non-nullabale owner property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); } else { @@ -211,7 +211,7 @@ public static CDP4Common.DTO.ReviewItemDiscrepancy FromJsonObject(JsonElement js { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); + Logger.Debug("The non-nullabale shortName property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); } else { @@ -239,7 +239,7 @@ public static CDP4Common.DTO.ReviewItemDiscrepancy FromJsonObject(JsonElement js { if(statusProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale status property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); + Logger.Debug("The non-nullabale status property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); } else { @@ -251,7 +251,7 @@ public static CDP4Common.DTO.ReviewItemDiscrepancy FromJsonObject(JsonElement js { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); + Logger.Debug("The non-nullabale thingPreference property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); } else { @@ -263,7 +263,7 @@ public static CDP4Common.DTO.ReviewItemDiscrepancy FromJsonObject(JsonElement js { if(titleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale title property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); + Logger.Debug("The non-nullabale title property of the reviewItemDiscrepancy {id} is null", reviewItemDiscrepancy.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/RuleVerificationListResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/RuleVerificationListResolver.cs index 2d970f52..428b4121 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/RuleVerificationListResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/RuleVerificationListResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.RuleVerificationList FromJsonObject(JsonElement jso { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the ruleVerificationList {id} is null", ruleVerificationList.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the ruleVerificationList {id} is null", ruleVerificationList.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.RuleVerificationList FromJsonObject(JsonElement jso { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the ruleVerificationList {id} is null", ruleVerificationList.Iid); + Logger.Debug("The non-nullabale name property of the ruleVerificationList {id} is null", ruleVerificationList.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.RuleVerificationList FromJsonObject(JsonElement jso { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the ruleVerificationList {id} is null", ruleVerificationList.Iid); + Logger.Debug("The non-nullabale owner property of the ruleVerificationList {id} is null", ruleVerificationList.Iid); } else { @@ -148,7 +148,7 @@ public static CDP4Common.DTO.RuleVerificationList FromJsonObject(JsonElement jso { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the ruleVerificationList {id} is null", ruleVerificationList.Iid); + Logger.Debug("The non-nullabale shortName property of the ruleVerificationList {id} is null", ruleVerificationList.Iid); } else { @@ -160,7 +160,7 @@ public static CDP4Common.DTO.RuleVerificationList FromJsonObject(JsonElement jso { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the ruleVerificationList {id} is null", ruleVerificationList.Iid); + Logger.Debug("The non-nullabale thingPreference property of the ruleVerificationList {id} is null", ruleVerificationList.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/RuleViolationResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/RuleViolationResolver.cs index 45a79e1d..45199c0d 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/RuleViolationResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/RuleViolationResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.RuleViolation FromJsonObject(JsonElement jsonElemen { if(descriptionProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale description property of the ruleViolation {id} is null", ruleViolation.Iid); + Logger.Debug("The non-nullabale description property of the ruleViolation {id} is null", ruleViolation.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.RuleViolation FromJsonObject(JsonElement jsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the ruleViolation {id} is null", ruleViolation.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the ruleViolation {id} is null", ruleViolation.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.RuleViolation FromJsonObject(JsonElement jsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the ruleViolation {id} is null", ruleViolation.Iid); + Logger.Debug("The non-nullabale thingPreference property of the ruleViolation {id} is null", ruleViolation.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SampledFunctionParameterTypeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SampledFunctionParameterTypeResolver.cs index 946660f7..c1d7c617 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SampledFunctionParameterTypeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SampledFunctionParameterTypeResolver.cs @@ -141,7 +141,7 @@ public static CDP4Common.DTO.SampledFunctionParameterType FromJsonObject(JsonEle { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); } else { @@ -153,7 +153,7 @@ public static CDP4Common.DTO.SampledFunctionParameterType FromJsonObject(JsonEle { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); } else { @@ -165,7 +165,7 @@ public static CDP4Common.DTO.SampledFunctionParameterType FromJsonObject(JsonEle { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); + Logger.Debug("The non-nullabale name property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); } else { @@ -177,7 +177,7 @@ public static CDP4Common.DTO.SampledFunctionParameterType FromJsonObject(JsonEle { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); + Logger.Debug("The non-nullabale shortName property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); } else { @@ -189,7 +189,7 @@ public static CDP4Common.DTO.SampledFunctionParameterType FromJsonObject(JsonEle { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); + Logger.Debug("The non-nullabale symbol property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); } else { @@ -201,7 +201,7 @@ public static CDP4Common.DTO.SampledFunctionParameterType FromJsonObject(JsonEle { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); + Logger.Debug("The non-nullabale thingPreference property of the sampledFunctionParameterType {id} is null", sampledFunctionParameterType.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ScaleReferenceQuantityValueResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ScaleReferenceQuantityValueResolver.cs index 4b915e1f..fde46eb3 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ScaleReferenceQuantityValueResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ScaleReferenceQuantityValueResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.ScaleReferenceQuantityValue FromJsonObject(JsonElem { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the scaleReferenceQuantityValue {id} is null", scaleReferenceQuantityValue.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the scaleReferenceQuantityValue {id} is null", scaleReferenceQuantityValue.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.ScaleReferenceQuantityValue FromJsonObject(JsonElem { if(scaleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale scale property of the scaleReferenceQuantityValue {id} is null", scaleReferenceQuantityValue.Iid); + Logger.Debug("The non-nullabale scale property of the scaleReferenceQuantityValue {id} is null", scaleReferenceQuantityValue.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ScaleReferenceQuantityValue FromJsonObject(JsonElem { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the scaleReferenceQuantityValue {id} is null", scaleReferenceQuantityValue.Iid); + Logger.Debug("The non-nullabale thingPreference property of the scaleReferenceQuantityValue {id} is null", scaleReferenceQuantityValue.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ScaleReferenceQuantityValue FromJsonObject(JsonElem { if(valueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale value property of the scaleReferenceQuantityValue {id} is null", scaleReferenceQuantityValue.Iid); + Logger.Debug("The non-nullabale value property of the scaleReferenceQuantityValue {id} is null", scaleReferenceQuantityValue.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ScaleValueDefinitionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ScaleValueDefinitionResolver.cs index 819ab270..3979cde6 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ScaleValueDefinitionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ScaleValueDefinitionResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.ScaleValueDefinition FromJsonObject(JsonElement jso { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the scaleValueDefinition {id} is null", scaleValueDefinition.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the scaleValueDefinition {id} is null", scaleValueDefinition.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.ScaleValueDefinition FromJsonObject(JsonElement jso { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the scaleValueDefinition {id} is null", scaleValueDefinition.Iid); + Logger.Debug("The non-nullabale name property of the scaleValueDefinition {id} is null", scaleValueDefinition.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.ScaleValueDefinition FromJsonObject(JsonElement jso { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the scaleValueDefinition {id} is null", scaleValueDefinition.Iid); + Logger.Debug("The non-nullabale shortName property of the scaleValueDefinition {id} is null", scaleValueDefinition.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.ScaleValueDefinition FromJsonObject(JsonElement jso { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the scaleValueDefinition {id} is null", scaleValueDefinition.Iid); + Logger.Debug("The non-nullabale thingPreference property of the scaleValueDefinition {id} is null", scaleValueDefinition.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.ScaleValueDefinition FromJsonObject(JsonElement jso { if(valueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale value property of the scaleValueDefinition {id} is null", scaleValueDefinition.Iid); + Logger.Debug("The non-nullabale value property of the scaleValueDefinition {id} is null", scaleValueDefinition.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SectionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SectionResolver.cs index 9fc4e315..9dbef1bc 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SectionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SectionResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.Section FromJsonObject(JsonElement jsonElement) { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the section {id} is null", section.Iid); + Logger.Debug("The non-nullabale createdOn property of the section {id} is null", section.Iid); } else { @@ -103,7 +103,7 @@ public static CDP4Common.DTO.Section FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the section {id} is null", section.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the section {id} is null", section.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.Section FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the section {id} is null", section.Iid); + Logger.Debug("The non-nullabale name property of the section {id} is null", section.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.Section FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the section {id} is null", section.Iid); + Logger.Debug("The non-nullabale owner property of the section {id} is null", section.Iid); } else { @@ -144,7 +144,7 @@ public static CDP4Common.DTO.Section FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the section {id} is null", section.Iid); + Logger.Debug("The non-nullabale shortName property of the section {id} is null", section.Iid); } else { @@ -156,7 +156,7 @@ public static CDP4Common.DTO.Section FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the section {id} is null", section.Iid); + Logger.Debug("The non-nullabale thingPreference property of the section {id} is null", section.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SharedStyleResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SharedStyleResolver.cs index cfa19318..3508f96d 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SharedStyleResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SharedStyleResolver.cs @@ -143,7 +143,7 @@ public static CDP4Common.DTO.SharedStyle FromJsonObject(JsonElement jsonElement) { if(fontNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale fontName property of the sharedStyle {id} is null", sharedStyle.Iid); + Logger.Debug("The non-nullabale fontName property of the sharedStyle {id} is null", sharedStyle.Iid); } else { @@ -191,7 +191,7 @@ public static CDP4Common.DTO.SharedStyle FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the sharedStyle {id} is null", sharedStyle.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the sharedStyle {id} is null", sharedStyle.Iid); } else { @@ -203,7 +203,7 @@ public static CDP4Common.DTO.SharedStyle FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the sharedStyle {id} is null", sharedStyle.Iid); + Logger.Debug("The non-nullabale name property of the sharedStyle {id} is null", sharedStyle.Iid); } else { @@ -251,7 +251,7 @@ public static CDP4Common.DTO.SharedStyle FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the sharedStyle {id} is null", sharedStyle.Iid); + Logger.Debug("The non-nullabale thingPreference property of the sharedStyle {id} is null", sharedStyle.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleParameterValueResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleParameterValueResolver.cs index fa8f3b82..bcc74430 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleParameterValueResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleParameterValueResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.SimpleParameterValue FromJsonObject(JsonElement jso { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the simpleParameterValue {id} is null", simpleParameterValue.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the simpleParameterValue {id} is null", simpleParameterValue.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.SimpleParameterValue FromJsonObject(JsonElement jso { if(parameterTypeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale parameterType property of the simpleParameterValue {id} is null", simpleParameterValue.Iid); + Logger.Debug("The non-nullabale parameterType property of the simpleParameterValue {id} is null", simpleParameterValue.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.SimpleParameterValue FromJsonObject(JsonElement jso { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the simpleParameterValue {id} is null", simpleParameterValue.Iid); + Logger.Debug("The non-nullabale thingPreference property of the simpleParameterValue {id} is null", simpleParameterValue.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleQuantityKindResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleQuantityKindResolver.cs index d3cf8a6e..b7b864b5 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleQuantityKindResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleQuantityKindResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.SimpleQuantityKind FromJsonObject(JsonElement jsonE { if(defaultScaleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale defaultScale property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); + Logger.Debug("The non-nullabale defaultScale property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.SimpleQuantityKind FromJsonObject(JsonElement jsonE { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.SimpleQuantityKind FromJsonObject(JsonElement jsonE { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.SimpleQuantityKind FromJsonObject(JsonElement jsonE { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); + Logger.Debug("The non-nullabale name property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); } else { @@ -171,7 +171,7 @@ public static CDP4Common.DTO.SimpleQuantityKind FromJsonObject(JsonElement jsonE { if(quantityDimensionSymbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale quantityDimensionSymbol property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); + Logger.Debug("The non-nullabale quantityDimensionSymbol property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); } else { @@ -183,7 +183,7 @@ public static CDP4Common.DTO.SimpleQuantityKind FromJsonObject(JsonElement jsonE { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); + Logger.Debug("The non-nullabale shortName property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); } else { @@ -195,7 +195,7 @@ public static CDP4Common.DTO.SimpleQuantityKind FromJsonObject(JsonElement jsonE { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); + Logger.Debug("The non-nullabale symbol property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); } else { @@ -207,7 +207,7 @@ public static CDP4Common.DTO.SimpleQuantityKind FromJsonObject(JsonElement jsonE { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); + Logger.Debug("The non-nullabale thingPreference property of the simpleQuantityKind {id} is null", simpleQuantityKind.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleUnitResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleUnitResolver.cs index 2e481286..53ac8fc4 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleUnitResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SimpleUnitResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.SimpleUnit FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the simpleUnit {id} is null", simpleUnit.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the simpleUnit {id} is null", simpleUnit.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.SimpleUnit FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the simpleUnit {id} is null", simpleUnit.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the simpleUnit {id} is null", simpleUnit.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.SimpleUnit FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the simpleUnit {id} is null", simpleUnit.Iid); + Logger.Debug("The non-nullabale name property of the simpleUnit {id} is null", simpleUnit.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.SimpleUnit FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the simpleUnit {id} is null", simpleUnit.Iid); + Logger.Debug("The non-nullabale shortName property of the simpleUnit {id} is null", simpleUnit.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.SimpleUnit FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the simpleUnit {id} is null", simpleUnit.Iid); + Logger.Debug("The non-nullabale thingPreference property of the simpleUnit {id} is null", simpleUnit.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryDataAnnotationResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryDataAnnotationResolver.cs index 68d422c8..2d60b0f1 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryDataAnnotationResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryDataAnnotationResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.SiteDirectoryDataAnnotation FromJsonObject(JsonElem { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); + Logger.Debug("The non-nullabale author property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); } else { @@ -79,7 +79,7 @@ public static CDP4Common.DTO.SiteDirectoryDataAnnotation FromJsonObject(JsonElem { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); + Logger.Debug("The non-nullabale content property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); } else { @@ -91,7 +91,7 @@ public static CDP4Common.DTO.SiteDirectoryDataAnnotation FromJsonObject(JsonElem { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); + Logger.Debug("The non-nullabale createdOn property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.SiteDirectoryDataAnnotation FromJsonObject(JsonElem { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); + Logger.Debug("The non-nullabale languageCode property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.SiteDirectoryDataAnnotation FromJsonObject(JsonElem { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.SiteDirectoryDataAnnotation FromJsonObject(JsonElem { if(primaryAnnotatedThingProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale primaryAnnotatedThing property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); + Logger.Debug("The non-nullabale primaryAnnotatedThing property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); } else { @@ -171,7 +171,7 @@ public static CDP4Common.DTO.SiteDirectoryDataAnnotation FromJsonObject(JsonElem { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); + Logger.Debug("The non-nullabale thingPreference property of the siteDirectoryDataAnnotation {id} is null", siteDirectoryDataAnnotation.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryDataDiscussionItemResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryDataDiscussionItemResolver.cs index 459029ad..71d00653 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryDataDiscussionItemResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryDataDiscussionItemResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.SiteDirectoryDataDiscussionItem FromJsonObject(Json { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale author property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); } else { @@ -79,7 +79,7 @@ public static CDP4Common.DTO.SiteDirectoryDataDiscussionItem FromJsonObject(Json { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale content property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); } else { @@ -91,7 +91,7 @@ public static CDP4Common.DTO.SiteDirectoryDataDiscussionItem FromJsonObject(Json { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale createdOn property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.SiteDirectoryDataDiscussionItem FromJsonObject(Json { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale languageCode property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.SiteDirectoryDataDiscussionItem FromJsonObject(Json { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.SiteDirectoryDataDiscussionItem FromJsonObject(Json { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); + Logger.Debug("The non-nullabale thingPreference property of the siteDirectoryDataDiscussionItem {id} is null", siteDirectoryDataDiscussionItem.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryResolver.cs index 6c3350b5..57db9f6e 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.SiteDirectory FromJsonObject(JsonElement jsonElemen { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the siteDirectory {id} is null", siteDirectory.Iid); + Logger.Debug("The non-nullabale createdOn property of the siteDirectory {id} is null", siteDirectory.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.SiteDirectory FromJsonObject(JsonElement jsonElemen { if(lastModifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale lastModifiedOn property of the siteDirectory {id} is null", siteDirectory.Iid); + Logger.Debug("The non-nullabale lastModifiedOn property of the siteDirectory {id} is null", siteDirectory.Iid); } else { @@ -171,7 +171,7 @@ public static CDP4Common.DTO.SiteDirectory FromJsonObject(JsonElement jsonElemen { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the siteDirectory {id} is null", siteDirectory.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the siteDirectory {id} is null", siteDirectory.Iid); } else { @@ -183,7 +183,7 @@ public static CDP4Common.DTO.SiteDirectory FromJsonObject(JsonElement jsonElemen { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the siteDirectory {id} is null", siteDirectory.Iid); + Logger.Debug("The non-nullabale name property of the siteDirectory {id} is null", siteDirectory.Iid); } else { @@ -235,7 +235,7 @@ public static CDP4Common.DTO.SiteDirectory FromJsonObject(JsonElement jsonElemen { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the siteDirectory {id} is null", siteDirectory.Iid); + Logger.Debug("The non-nullabale shortName property of the siteDirectory {id} is null", siteDirectory.Iid); } else { @@ -255,7 +255,7 @@ public static CDP4Common.DTO.SiteDirectory FromJsonObject(JsonElement jsonElemen { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the siteDirectory {id} is null", siteDirectory.Iid); + Logger.Debug("The non-nullabale thingPreference property of the siteDirectory {id} is null", siteDirectory.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryThingReferenceResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryThingReferenceResolver.cs index 11ccc900..28946bf1 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryThingReferenceResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteDirectoryThingReferenceResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.SiteDirectoryThingReference FromJsonObject(JsonElem { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the siteDirectoryThingReference {id} is null", siteDirectoryThingReference.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the siteDirectoryThingReference {id} is null", siteDirectoryThingReference.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.SiteDirectoryThingReference FromJsonObject(JsonElem { if(referencedRevisionNumberProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale referencedRevisionNumber property of the siteDirectoryThingReference {id} is null", siteDirectoryThingReference.Iid); + Logger.Debug("The non-nullabale referencedRevisionNumber property of the siteDirectoryThingReference {id} is null", siteDirectoryThingReference.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.SiteDirectoryThingReference FromJsonObject(JsonElem { if(referencedThingProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale referencedThing property of the siteDirectoryThingReference {id} is null", siteDirectoryThingReference.Iid); + Logger.Debug("The non-nullabale referencedThing property of the siteDirectoryThingReference {id} is null", siteDirectoryThingReference.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.SiteDirectoryThingReference FromJsonObject(JsonElem { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the siteDirectoryThingReference {id} is null", siteDirectoryThingReference.Iid); + Logger.Debug("The non-nullabale thingPreference property of the siteDirectoryThingReference {id} is null", siteDirectoryThingReference.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteLogEntryResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteLogEntryResolver.cs index a3c5db28..2e9c5fab 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteLogEntryResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteLogEntryResolver.cs @@ -103,7 +103,7 @@ public static CDP4Common.DTO.SiteLogEntry FromJsonObject(JsonElement jsonElement { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the siteLogEntry {id} is null", siteLogEntry.Iid); + Logger.Debug("The non-nullabale content property of the siteLogEntry {id} is null", siteLogEntry.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.SiteLogEntry FromJsonObject(JsonElement jsonElement { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the siteLogEntry {id} is null", siteLogEntry.Iid); + Logger.Debug("The non-nullabale createdOn property of the siteLogEntry {id} is null", siteLogEntry.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.SiteLogEntry FromJsonObject(JsonElement jsonElement { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the siteLogEntry {id} is null", siteLogEntry.Iid); + Logger.Debug("The non-nullabale languageCode property of the siteLogEntry {id} is null", siteLogEntry.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.SiteLogEntry FromJsonObject(JsonElement jsonElement { if(levelProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale level property of the siteLogEntry {id} is null", siteLogEntry.Iid); + Logger.Debug("The non-nullabale level property of the siteLogEntry {id} is null", siteLogEntry.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.SiteLogEntry FromJsonObject(JsonElement jsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the siteLogEntry {id} is null", siteLogEntry.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the siteLogEntry {id} is null", siteLogEntry.Iid); } else { @@ -187,7 +187,7 @@ public static CDP4Common.DTO.SiteLogEntry FromJsonObject(JsonElement jsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the siteLogEntry {id} is null", siteLogEntry.Iid); + Logger.Debug("The non-nullabale thingPreference property of the siteLogEntry {id} is null", siteLogEntry.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteReferenceDataLibraryResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteReferenceDataLibraryResolver.cs index dd212ecb..fc7c9afd 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteReferenceDataLibraryResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SiteReferenceDataLibraryResolver.cs @@ -152,7 +152,7 @@ public static CDP4Common.DTO.SiteReferenceDataLibrary FromJsonObject(JsonElement { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the siteReferenceDataLibrary {id} is null", siteReferenceDataLibrary.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the siteReferenceDataLibrary {id} is null", siteReferenceDataLibrary.Iid); } else { @@ -164,7 +164,7 @@ public static CDP4Common.DTO.SiteReferenceDataLibrary FromJsonObject(JsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the siteReferenceDataLibrary {id} is null", siteReferenceDataLibrary.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the siteReferenceDataLibrary {id} is null", siteReferenceDataLibrary.Iid); } else { @@ -176,7 +176,7 @@ public static CDP4Common.DTO.SiteReferenceDataLibrary FromJsonObject(JsonElement { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the siteReferenceDataLibrary {id} is null", siteReferenceDataLibrary.Iid); + Logger.Debug("The non-nullabale name property of the siteReferenceDataLibrary {id} is null", siteReferenceDataLibrary.Iid); } else { @@ -232,7 +232,7 @@ public static CDP4Common.DTO.SiteReferenceDataLibrary FromJsonObject(JsonElement { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the siteReferenceDataLibrary {id} is null", siteReferenceDataLibrary.Iid); + Logger.Debug("The non-nullabale shortName property of the siteReferenceDataLibrary {id} is null", siteReferenceDataLibrary.Iid); } else { @@ -244,7 +244,7 @@ public static CDP4Common.DTO.SiteReferenceDataLibrary FromJsonObject(JsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the siteReferenceDataLibrary {id} is null", siteReferenceDataLibrary.Iid); + Logger.Debug("The non-nullabale thingPreference property of the siteReferenceDataLibrary {id} is null", siteReferenceDataLibrary.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SolutionResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SolutionResolver.cs index 9d427ee8..37940cf9 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SolutionResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SolutionResolver.cs @@ -67,7 +67,7 @@ public static CDP4Common.DTO.Solution FromJsonObject(JsonElement jsonElement) { if(authorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale author property of the solution {id} is null", solution.Iid); + Logger.Debug("The non-nullabale author property of the solution {id} is null", solution.Iid); } else { @@ -79,7 +79,7 @@ public static CDP4Common.DTO.Solution FromJsonObject(JsonElement jsonElement) { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the solution {id} is null", solution.Iid); + Logger.Debug("The non-nullabale content property of the solution {id} is null", solution.Iid); } else { @@ -91,7 +91,7 @@ public static CDP4Common.DTO.Solution FromJsonObject(JsonElement jsonElement) { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the solution {id} is null", solution.Iid); + Logger.Debug("The non-nullabale createdOn property of the solution {id} is null", solution.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.Solution FromJsonObject(JsonElement jsonElement) { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the solution {id} is null", solution.Iid); + Logger.Debug("The non-nullabale languageCode property of the solution {id} is null", solution.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Solution FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the solution {id} is null", solution.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the solution {id} is null", solution.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.Solution FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the solution {id} is null", solution.Iid); + Logger.Debug("The non-nullabale owner property of the solution {id} is null", solution.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.Solution FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the solution {id} is null", solution.Iid); + Logger.Debug("The non-nullabale thingPreference property of the solution {id} is null", solution.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/SpecializedQuantityKindResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/SpecializedQuantityKindResolver.cs index 8c7076c2..dc593f90 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/SpecializedQuantityKindResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/SpecializedQuantityKindResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.SpecializedQuantityKind FromJsonObject(JsonElement { if(defaultScaleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale defaultScale property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); + Logger.Debug("The non-nullabale defaultScale property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.SpecializedQuantityKind FromJsonObject(JsonElement { if(generalProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale general property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); + Logger.Debug("The non-nullabale general property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.SpecializedQuantityKind FromJsonObject(JsonElement { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.SpecializedQuantityKind FromJsonObject(JsonElement { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.SpecializedQuantityKind FromJsonObject(JsonElement { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); + Logger.Debug("The non-nullabale name property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); } else { @@ -183,7 +183,7 @@ public static CDP4Common.DTO.SpecializedQuantityKind FromJsonObject(JsonElement { if(quantityDimensionSymbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale quantityDimensionSymbol property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); + Logger.Debug("The non-nullabale quantityDimensionSymbol property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); } else { @@ -195,7 +195,7 @@ public static CDP4Common.DTO.SpecializedQuantityKind FromJsonObject(JsonElement { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); + Logger.Debug("The non-nullabale shortName property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); } else { @@ -207,7 +207,7 @@ public static CDP4Common.DTO.SpecializedQuantityKind FromJsonObject(JsonElement { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); + Logger.Debug("The non-nullabale symbol property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); } else { @@ -219,7 +219,7 @@ public static CDP4Common.DTO.SpecializedQuantityKind FromJsonObject(JsonElement { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); + Logger.Debug("The non-nullabale thingPreference property of the specializedQuantityKind {id} is null", specializedQuantityKind.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeHolderValueMapResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeHolderValueMapResolver.cs index 5795d07a..2a3d0bc4 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeHolderValueMapResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeHolderValueMapResolver.cs @@ -123,7 +123,7 @@ public static CDP4Common.DTO.StakeHolderValueMap FromJsonObject(JsonElement json { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the stakeHolderValueMap {id} is null", stakeHolderValueMap.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the stakeHolderValueMap {id} is null", stakeHolderValueMap.Iid); } else { @@ -135,7 +135,7 @@ public static CDP4Common.DTO.StakeHolderValueMap FromJsonObject(JsonElement json { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the stakeHolderValueMap {id} is null", stakeHolderValueMap.Iid); + Logger.Debug("The non-nullabale name property of the stakeHolderValueMap {id} is null", stakeHolderValueMap.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.StakeHolderValueMap FromJsonObject(JsonElement json { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the stakeHolderValueMap {id} is null", stakeHolderValueMap.Iid); + Logger.Debug("The non-nullabale shortName property of the stakeHolderValueMap {id} is null", stakeHolderValueMap.Iid); } else { @@ -183,7 +183,7 @@ public static CDP4Common.DTO.StakeHolderValueMap FromJsonObject(JsonElement json { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the stakeHolderValueMap {id} is null", stakeHolderValueMap.Iid); + Logger.Debug("The non-nullabale thingPreference property of the stakeHolderValueMap {id} is null", stakeHolderValueMap.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeHolderValueMapSettingsResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeHolderValueMapSettingsResolver.cs index 9863c548..cf611c63 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeHolderValueMapSettingsResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeHolderValueMapSettingsResolver.cs @@ -95,7 +95,7 @@ public static CDP4Common.DTO.StakeHolderValueMapSettings FromJsonObject(JsonElem { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the stakeHolderValueMapSettings {id} is null", stakeHolderValueMapSettings.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the stakeHolderValueMapSettings {id} is null", stakeHolderValueMapSettings.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.StakeHolderValueMapSettings FromJsonObject(JsonElem { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the stakeHolderValueMapSettings {id} is null", stakeHolderValueMapSettings.Iid); + Logger.Debug("The non-nullabale thingPreference property of the stakeHolderValueMapSettings {id} is null", stakeHolderValueMapSettings.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeholderResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeholderResolver.cs index 2a4191a5..36e471fe 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeholderResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeholderResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.Stakeholder FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the stakeholder {id} is null", stakeholder.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the stakeholder {id} is null", stakeholder.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.Stakeholder FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the stakeholder {id} is null", stakeholder.Iid); + Logger.Debug("The non-nullabale name property of the stakeholder {id} is null", stakeholder.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.Stakeholder FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the stakeholder {id} is null", stakeholder.Iid); + Logger.Debug("The non-nullabale shortName property of the stakeholder {id} is null", stakeholder.Iid); } else { @@ -159,7 +159,7 @@ public static CDP4Common.DTO.Stakeholder FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the stakeholder {id} is null", stakeholder.Iid); + Logger.Debug("The non-nullabale thingPreference property of the stakeholder {id} is null", stakeholder.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeholderValueResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeholderValueResolver.cs index 88d7c6a4..be7fa187 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeholderValueResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/StakeholderValueResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.StakeholderValue FromJsonObject(JsonElement jsonEle { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the stakeholderValue {id} is null", stakeholderValue.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the stakeholderValue {id} is null", stakeholderValue.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.StakeholderValue FromJsonObject(JsonElement jsonEle { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the stakeholderValue {id} is null", stakeholderValue.Iid); + Logger.Debug("The non-nullabale name property of the stakeholderValue {id} is null", stakeholderValue.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.StakeholderValue FromJsonObject(JsonElement jsonEle { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the stakeholderValue {id} is null", stakeholderValue.Iid); + Logger.Debug("The non-nullabale shortName property of the stakeholderValue {id} is null", stakeholderValue.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.StakeholderValue FromJsonObject(JsonElement jsonEle { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the stakeholderValue {id} is null", stakeholderValue.Iid); + Logger.Debug("The non-nullabale thingPreference property of the stakeholderValue {id} is null", stakeholderValue.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/TelephoneNumberResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/TelephoneNumberResolver.cs index 95b744ff..775ad6bd 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/TelephoneNumberResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/TelephoneNumberResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.TelephoneNumber FromJsonObject(JsonElement jsonElem { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the telephoneNumber {id} is null", telephoneNumber.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the telephoneNumber {id} is null", telephoneNumber.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.TelephoneNumber FromJsonObject(JsonElement jsonElem { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the telephoneNumber {id} is null", telephoneNumber.Iid); + Logger.Debug("The non-nullabale thingPreference property of the telephoneNumber {id} is null", telephoneNumber.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.TelephoneNumber FromJsonObject(JsonElement jsonElem { if(valueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale value property of the telephoneNumber {id} is null", telephoneNumber.Iid); + Logger.Debug("The non-nullabale value property of the telephoneNumber {id} is null", telephoneNumber.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/TermResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/TermResolver.cs index ed17540c..a2a92daa 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/TermResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/TermResolver.cs @@ -107,7 +107,7 @@ public static CDP4Common.DTO.Term FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the term {id} is null", term.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the term {id} is null", term.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.Term FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the term {id} is null", term.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the term {id} is null", term.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.Term FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the term {id} is null", term.Iid); + Logger.Debug("The non-nullabale name property of the term {id} is null", term.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.Term FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the term {id} is null", term.Iid); + Logger.Debug("The non-nullabale shortName property of the term {id} is null", term.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.Term FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the term {id} is null", term.Iid); + Logger.Debug("The non-nullabale thingPreference property of the term {id} is null", term.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/TextParameterTypeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/TextParameterTypeResolver.cs index ae9fbb9d..c8850740 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/TextParameterTypeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/TextParameterTypeResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.TextParameterType FromJsonObject(JsonElement jsonEl { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the textParameterType {id} is null", textParameterType.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the textParameterType {id} is null", textParameterType.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.TextParameterType FromJsonObject(JsonElement jsonEl { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the textParameterType {id} is null", textParameterType.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the textParameterType {id} is null", textParameterType.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.TextParameterType FromJsonObject(JsonElement jsonEl { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the textParameterType {id} is null", textParameterType.Iid); + Logger.Debug("The non-nullabale name property of the textParameterType {id} is null", textParameterType.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.TextParameterType FromJsonObject(JsonElement jsonEl { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the textParameterType {id} is null", textParameterType.Iid); + Logger.Debug("The non-nullabale shortName property of the textParameterType {id} is null", textParameterType.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.TextParameterType FromJsonObject(JsonElement jsonEl { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the textParameterType {id} is null", textParameterType.Iid); + Logger.Debug("The non-nullabale symbol property of the textParameterType {id} is null", textParameterType.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.TextParameterType FromJsonObject(JsonElement jsonEl { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the textParameterType {id} is null", textParameterType.Iid); + Logger.Debug("The non-nullabale thingPreference property of the textParameterType {id} is null", textParameterType.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/TextualNoteResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/TextualNoteResolver.cs index 14391575..490706e1 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/TextualNoteResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/TextualNoteResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.TextualNote FromJsonObject(JsonElement jsonElement) { if(contentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale content property of the textualNote {id} is null", textualNote.Iid); + Logger.Debug("The non-nullabale content property of the textualNote {id} is null", textualNote.Iid); } else { @@ -87,7 +87,7 @@ public static CDP4Common.DTO.TextualNote FromJsonObject(JsonElement jsonElement) { if(createdOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale createdOn property of the textualNote {id} is null", textualNote.Iid); + Logger.Debug("The non-nullabale createdOn property of the textualNote {id} is null", textualNote.Iid); } else { @@ -115,7 +115,7 @@ public static CDP4Common.DTO.TextualNote FromJsonObject(JsonElement jsonElement) { if(languageCodeProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale languageCode property of the textualNote {id} is null", textualNote.Iid); + Logger.Debug("The non-nullabale languageCode property of the textualNote {id} is null", textualNote.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.TextualNote FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the textualNote {id} is null", textualNote.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the textualNote {id} is null", textualNote.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.TextualNote FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the textualNote {id} is null", textualNote.Iid); + Logger.Debug("The non-nullabale name property of the textualNote {id} is null", textualNote.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.TextualNote FromJsonObject(JsonElement jsonElement) { if(ownerProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale owner property of the textualNote {id} is null", textualNote.Iid); + Logger.Debug("The non-nullabale owner property of the textualNote {id} is null", textualNote.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.TextualNote FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the textualNote {id} is null", textualNote.Iid); + Logger.Debug("The non-nullabale shortName property of the textualNote {id} is null", textualNote.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.TextualNote FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the textualNote {id} is null", textualNote.Iid); + Logger.Debug("The non-nullabale thingPreference property of the textualNote {id} is null", textualNote.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/TimeOfDayParameterTypeResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/TimeOfDayParameterTypeResolver.cs index 1cea5753..218e355c 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/TimeOfDayParameterTypeResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/TimeOfDayParameterTypeResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.TimeOfDayParameterType FromJsonObject(JsonElement j { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.TimeOfDayParameterType FromJsonObject(JsonElement j { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.TimeOfDayParameterType FromJsonObject(JsonElement j { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); + Logger.Debug("The non-nullabale name property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.TimeOfDayParameterType FromJsonObject(JsonElement j { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); + Logger.Debug("The non-nullabale shortName property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); } else { @@ -163,7 +163,7 @@ public static CDP4Common.DTO.TimeOfDayParameterType FromJsonObject(JsonElement j { if(symbolProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale symbol property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); + Logger.Debug("The non-nullabale symbol property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); } else { @@ -175,7 +175,7 @@ public static CDP4Common.DTO.TimeOfDayParameterType FromJsonObject(JsonElement j { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); + Logger.Debug("The non-nullabale thingPreference property of the timeOfDayParameterType {id} is null", timeOfDayParameterType.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/UnitFactorResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/UnitFactorResolver.cs index 217ebd13..147ac291 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/UnitFactorResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/UnitFactorResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.UnitFactor FromJsonObject(JsonElement jsonElement) { if(exponentProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale exponent property of the unitFactor {id} is null", unitFactor.Iid); + Logger.Debug("The non-nullabale exponent property of the unitFactor {id} is null", unitFactor.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.UnitFactor FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the unitFactor {id} is null", unitFactor.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the unitFactor {id} is null", unitFactor.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.UnitFactor FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the unitFactor {id} is null", unitFactor.Iid); + Logger.Debug("The non-nullabale thingPreference property of the unitFactor {id} is null", unitFactor.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.UnitFactor FromJsonObject(JsonElement jsonElement) { if(unitProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale unit property of the unitFactor {id} is null", unitFactor.Iid); + Logger.Debug("The non-nullabale unit property of the unitFactor {id} is null", unitFactor.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/UnitPrefixResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/UnitPrefixResolver.cs index 7871cf4e..9abd0988 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/UnitPrefixResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/UnitPrefixResolver.cs @@ -75,7 +75,7 @@ public static CDP4Common.DTO.UnitPrefix FromJsonObject(JsonElement jsonElement) { if(conversionFactorProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale conversionFactor property of the unitPrefix {id} is null", unitPrefix.Iid); + Logger.Debug("The non-nullabale conversionFactor property of the unitPrefix {id} is null", unitPrefix.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.UnitPrefix FromJsonObject(JsonElement jsonElement) { if(isDeprecatedProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isDeprecated property of the unitPrefix {id} is null", unitPrefix.Iid); + Logger.Debug("The non-nullabale isDeprecated property of the unitPrefix {id} is null", unitPrefix.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.UnitPrefix FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the unitPrefix {id} is null", unitPrefix.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the unitPrefix {id} is null", unitPrefix.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.UnitPrefix FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the unitPrefix {id} is null", unitPrefix.Iid); + Logger.Debug("The non-nullabale name property of the unitPrefix {id} is null", unitPrefix.Iid); } else { @@ -155,7 +155,7 @@ public static CDP4Common.DTO.UnitPrefix FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the unitPrefix {id} is null", unitPrefix.Iid); + Logger.Debug("The non-nullabale shortName property of the unitPrefix {id} is null", unitPrefix.Iid); } else { @@ -167,7 +167,7 @@ public static CDP4Common.DTO.UnitPrefix FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the unitPrefix {id} is null", unitPrefix.Iid); + Logger.Debug("The non-nullabale thingPreference property of the unitPrefix {id} is null", unitPrefix.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/UserPreferenceResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/UserPreferenceResolver.cs index 20bea185..5a3ec842 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/UserPreferenceResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/UserPreferenceResolver.cs @@ -83,7 +83,7 @@ public static CDP4Common.DTO.UserPreference FromJsonObject(JsonElement jsonEleme { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the userPreference {id} is null", userPreference.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the userPreference {id} is null", userPreference.Iid); } else { @@ -95,7 +95,7 @@ public static CDP4Common.DTO.UserPreference FromJsonObject(JsonElement jsonEleme { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the userPreference {id} is null", userPreference.Iid); + Logger.Debug("The non-nullabale shortName property of the userPreference {id} is null", userPreference.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.UserPreference FromJsonObject(JsonElement jsonEleme { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the userPreference {id} is null", userPreference.Iid); + Logger.Debug("The non-nullabale thingPreference property of the userPreference {id} is null", userPreference.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.UserPreference FromJsonObject(JsonElement jsonEleme { if(valueProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale value property of the userPreference {id} is null", userPreference.Iid); + Logger.Debug("The non-nullabale value property of the userPreference {id} is null", userPreference.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/UserRuleVerificationResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/UserRuleVerificationResolver.cs index d5edbfa4..55801be0 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/UserRuleVerificationResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/UserRuleVerificationResolver.cs @@ -95,7 +95,7 @@ public static CDP4Common.DTO.UserRuleVerification FromJsonObject(JsonElement jso { if(isActiveProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale isActive property of the userRuleVerification {id} is null", userRuleVerification.Iid); + Logger.Debug("The non-nullabale isActive property of the userRuleVerification {id} is null", userRuleVerification.Iid); } else { @@ -107,7 +107,7 @@ public static CDP4Common.DTO.UserRuleVerification FromJsonObject(JsonElement jso { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the userRuleVerification {id} is null", userRuleVerification.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the userRuleVerification {id} is null", userRuleVerification.Iid); } else { @@ -119,7 +119,7 @@ public static CDP4Common.DTO.UserRuleVerification FromJsonObject(JsonElement jso { if(ruleProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale rule property of the userRuleVerification {id} is null", userRuleVerification.Iid); + Logger.Debug("The non-nullabale rule property of the userRuleVerification {id} is null", userRuleVerification.Iid); } else { @@ -131,7 +131,7 @@ public static CDP4Common.DTO.UserRuleVerification FromJsonObject(JsonElement jso { if(statusProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale status property of the userRuleVerification {id} is null", userRuleVerification.Iid); + Logger.Debug("The non-nullabale status property of the userRuleVerification {id} is null", userRuleVerification.Iid); } else { @@ -143,7 +143,7 @@ public static CDP4Common.DTO.UserRuleVerification FromJsonObject(JsonElement jso { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the userRuleVerification {id} is null", userRuleVerification.Iid); + Logger.Debug("The non-nullabale thingPreference property of the userRuleVerification {id} is null", userRuleVerification.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoDeserializer/ValueGroupResolver.cs b/CDP4JsonSerializer/AutoGenDtoDeserializer/ValueGroupResolver.cs index b7cb379d..8fe97a0b 100644 --- a/CDP4JsonSerializer/AutoGenDtoDeserializer/ValueGroupResolver.cs +++ b/CDP4JsonSerializer/AutoGenDtoDeserializer/ValueGroupResolver.cs @@ -115,7 +115,7 @@ public static CDP4Common.DTO.ValueGroup FromJsonObject(JsonElement jsonElement) { if(modifiedOnProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale modifiedOn property of the valueGroup {id} is null", valueGroup.Iid); + Logger.Debug("The non-nullabale modifiedOn property of the valueGroup {id} is null", valueGroup.Iid); } else { @@ -127,7 +127,7 @@ public static CDP4Common.DTO.ValueGroup FromJsonObject(JsonElement jsonElement) { if(nameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale name property of the valueGroup {id} is null", valueGroup.Iid); + Logger.Debug("The non-nullabale name property of the valueGroup {id} is null", valueGroup.Iid); } else { @@ -139,7 +139,7 @@ public static CDP4Common.DTO.ValueGroup FromJsonObject(JsonElement jsonElement) { if(shortNameProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale shortName property of the valueGroup {id} is null", valueGroup.Iid); + Logger.Debug("The non-nullabale shortName property of the valueGroup {id} is null", valueGroup.Iid); } else { @@ -151,7 +151,7 @@ public static CDP4Common.DTO.ValueGroup FromJsonObject(JsonElement jsonElement) { if(thingPreferenceProperty.ValueKind == JsonValueKind.Null) { - Logger.Trace("The non-nullabale thingPreference property of the valueGroup {id} is null", valueGroup.Iid); + Logger.Debug("The non-nullabale thingPreference property of the valueGroup {id} is null", valueGroup.Iid); } else { diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ActionItemSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ActionItemSerializer.cs index 1084b3f8..50c743b8 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ActionItemSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ActionItemSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,437 +50,459 @@ namespace CDP4JsonSerializer public class ActionItemSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ActionItem actionItem) - { - throw new ArgumentException("The thing shall be a ActionItem", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.1.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of ActionItem since Version is below 1.1.0"); - return; - } + case "actionee": + var allowedVersionsForActionee = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartObject(); + if(!allowedVersionsForActionee.Contains(requestedVersion)) + { + return; + } - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ActionItem for Version 1.1.0"); writer.WritePropertyName("actionee"u8); - writer.WriteStringValue(actionItem.Actionee); - writer.WriteStartArray("approvedBy"u8); - - foreach(var approvedByItem in actionItem.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(approvedByItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(actionItem.Author); - writer.WriteStartArray("category"u8); + break; + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var categoryItem in actionItem.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(actionItem.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(actionItem.ClassKind.ToString()); - writer.WritePropertyName("closeOutDate"u8); - - if(actionItem.CloseOutDate.HasValue) + if(value != null) { - writer.WriteStringValue(actionItem.CloseOutDate.Value.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("closeOutStatement"u8); - writer.WriteStringValue(actionItem.CloseOutStatement); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(actionItem.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(actionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "approvedby": + var allowedVersionsForApprovedBy = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in actionItem.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForApprovedBy.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("dueDate"u8); - writer.WriteStringValue(actionItem.DueDate.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("approvedBy"u8); - foreach(var excludedDomainItem in actionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListApprovedBy) { - writer.WriteStringValue(excludedDomainItem); + foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(approvedByItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "author": + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in actionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("author"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(actionItem.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(actionItem.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(actionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(actionItem.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(actionItem.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(actionItem.PrimaryAnnotatedThing.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var relatedThingItem in actionItem.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(relatedThingItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(actionItem.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(actionItem.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + writer.WriteStartArray("category"u8); - foreach(var sourceAnnotationItem in actionItem.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(sourceAnnotationItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(actionItem.Status.ToString()); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(actionItem.Title); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ActionItem for Version 1.2.0"); - writer.WritePropertyName("actionee"u8); - writer.WriteStringValue(actionItem.Actionee); - writer.WriteStartArray("approvedBy"u8); + case "classification": + var allowedVersionsForClassification = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in actionItem.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassification.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(actionItem.Author); - writer.WriteStartArray("category"u8); + if(value != null) + { + writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } - foreach(var categoryItem in actionItem.Category.OrderBy(x => x, this.GuidComparer)) + break; + case "classkind": + var allowedVersionsForClassKind = new List { - writer.WriteStringValue(categoryItem); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(actionItem.Classification.ToString()); writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(actionItem.ClassKind.ToString()); - writer.WritePropertyName("closeOutDate"u8); - - if(actionItem.CloseOutDate.HasValue) + + if(value != null) { - writer.WriteStringValue(actionItem.CloseOutDate.Value.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WritePropertyName("closeOutStatement"u8); - writer.WriteStringValue(actionItem.CloseOutStatement); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(actionItem.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(actionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "closeoutdate": + var allowedVersionsForCloseOutDate = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in actionItem.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCloseOutDate.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("closeOutDate"u8); - writer.WritePropertyName("dueDate"u8); - writer.WriteStringValue(actionItem.DueDate.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in actionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "closeoutstatement": + var allowedVersionsForCloseOutStatement = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in actionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCloseOutStatement.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("closeOutStatement"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(actionItem.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(actionItem.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(actionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(actionItem.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(actionItem.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(actionItem.PrimaryAnnotatedThing.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); + break; + case "content": + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var relatedThingItem in actionItem.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContent.Contains(requestedVersion)) { - writer.WriteStringValue(relatedThingItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("content"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(actionItem.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(actionItem.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); - - foreach(var sourceAnnotationItem in actionItem.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(sourceAnnotationItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("status"u8); - writer.WriteStringValue(actionItem.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(actionItem.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(actionItem.Title); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ActionItem for Version 1.3.0"); - writer.WritePropertyName("actionee"u8); - writer.WriteStringValue(actionItem.Actionee); - writer.WritePropertyName("actor"u8); + case "createdon": + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(actionItem.Actor.HasValue) + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { - writer.WriteStringValue(actionItem.Actor.Value); + return; + } + + writer.WritePropertyName("createdOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("approvedBy"u8); + break; + case "discussion": + var allowedVersionsForDiscussion = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in actionItem.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDiscussion.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("discussion"u8); + + if(value is IEnumerable objectListDiscussion) + { + foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } + } - writer.WritePropertyName("author"u8); - writer.WriteStringValue(actionItem.Author); - writer.WriteStartArray("category"u8); + writer.WriteEndArray(); + break; + case "duedate": + var allowedVersionsForDueDate = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in actionItem.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDueDate.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("dueDate"u8); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(actionItem.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(actionItem.ClassKind.ToString()); - writer.WritePropertyName("closeOutDate"u8); - - if(actionItem.CloseOutDate.HasValue) + if(value != null) { - writer.WriteStringValue(actionItem.CloseOutDate.Value.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WritePropertyName("closeOutStatement"u8); - writer.WriteStringValue(actionItem.CloseOutStatement); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(actionItem.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(actionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in actionItem.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("dueDate"u8); - writer.WriteStringValue(actionItem.DueDate.ToString(SerializerHelper.DateTimeFormat)); writer.WriteStartArray("excludedDomain"u8); - foreach(var excludedDomainItem in actionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in actionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(actionItem.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(actionItem.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(actionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(actionItem.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(actionItem.PrimaryAnnotatedThing.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(actionItem.PrimaryAnnotatedThing.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); + break; + case "languagecode": + var allowedVersionsForLanguageCode = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var relatedThingItem in actionItem.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { - writer.WriteStringValue(relatedThingItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("languageCode"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(actionItem.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(actionItem.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); - - foreach(var sourceAnnotationItem in actionItem.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(sourceAnnotationItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("status"u8); - writer.WriteStringValue(actionItem.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(actionItem.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(actionItem.Title); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actionee": - if(!AllowedVersionsPerProperty["actionee"].Contains(requestedVersion)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actionee"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -489,13 +510,20 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + case "owner": + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("owner"u8); if(value != null) { @@ -507,31 +535,20 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "approvedby": - if(!AllowedVersionsPerProperty["approvedBy"].Contains(requestedVersion)) + case "primaryannotatedthing": + var allowedVersionsForPrimaryAnnotatedThing = new List { - return; - } - - writer.WriteStartArray("approvedBy"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListApprovedBy) - { - foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(approvedByItem); - } - } - - writer.WriteEndArray(); - break; - case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + if(!allowedVersionsForPrimaryAnnotatedThing.Contains(requestedVersion)) { return; } - writer.WritePropertyName("author"u8); + writer.WritePropertyName("primaryAnnotatedThing"u8); if(value != null) { @@ -543,35 +560,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "relatedthing": + var allowedVersionsForRelatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRelatedThing.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("relatedThing"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListRelatedThing) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(relatedThingItem); } } writer.WriteEndArray(); break; - case "classification": - if(!AllowedVersionsPerProperty["classification"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classification"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -579,17 +610,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -597,35 +635,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "closeoutdate": - if(!AllowedVersionsPerProperty["closeOutDate"].Contains(requestedVersion)) + case "sourceannotation": + var allowedVersionsForSourceAnnotation = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSourceAnnotation.Contains(requestedVersion)) { return; } - writer.WritePropertyName("closeOutDate"u8); - - if(value != null) + writer.WriteStartArray("sourceAnnotation"u8); + + if(value is IEnumerable objectListSourceAnnotation) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); + foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); + } } - + + writer.WriteEndArray(); break; - case "closeoutstatement": - if(!AllowedVersionsPerProperty["closeOutStatement"].Contains(requestedVersion)) + case "status": + var allowedVersionsForStatus = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStatus.Contains(requestedVersion)) { return; } - writer.WritePropertyName("closeOutStatement"u8); + writer.WritePropertyName("status"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); } else { @@ -633,13 +685,19 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("content"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { @@ -651,17 +709,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + case "title": + var allowedVersionsForTitle = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTitle.Contains(requestedVersion)) { return; } - writer.WritePropertyName("createdOn"u8); + writer.WritePropertyName("title"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((string)value); } else { @@ -669,332 +734,396 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "discussion": - if(!AllowedVersionsPerProperty["discussion"].Contains(requestedVersion)) - { - return; - } + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ActionItem"); + } + } - writer.WriteStartArray("discussion"u8); + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ActionItem actionItem) + { + throw new ArgumentException("The thing shall be a ActionItem", nameof(thing)); + } - if(value is IEnumerable objectListDiscussion) + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ActionItem since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ActionItem for Version 1.1.0"); + writer.WritePropertyName("actionee"u8); + writer.WriteStringValue(actionItem.Actionee); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in actionItem.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } + writer.WriteStringValue(approvedByItem); } - + writer.WriteEndArray(); - break; - case "duedate": - if(!AllowedVersionsPerProperty["dueDate"].Contains(requestedVersion)) + writer.WritePropertyName("author"u8); + writer.WriteStringValue(actionItem.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in actionItem.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("dueDate"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(actionItem.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(actionItem.ClassKind.ToString()); + writer.WritePropertyName("closeOutDate"u8); + + if(actionItem.CloseOutDate.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(actionItem.CloseOutDate.Value.ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + writer.WritePropertyName("closeOutStatement"u8); + writer.WriteStringValue(actionItem.CloseOutStatement); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(actionItem.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(actionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in actionItem.Discussion.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(discussionItem); } + writer.WriteEndArray(); + writer.WritePropertyName("dueDate"u8); + writer.WriteStringValue(actionItem.DueDate.ToString(SerializerHelper.DateTimeFormat)); writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + foreach(var excludedDomainItem in actionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + foreach(var excludedPersonItem in actionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteStringValue(actionItem.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(actionItem.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(actionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(actionItem.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(actionItem.PrimaryAnnotatedThing.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(actionItem.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in actionItem.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); } - writer.WritePropertyName("languageCode"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(actionItem.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(actionItem.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in actionItem.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(sourceAnnotationItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(actionItem.Status.ToString()); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(actionItem.Title); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ActionItem for Version 1.2.0"); + writer.WritePropertyName("actionee"u8); + writer.WriteStringValue(actionItem.Actionee); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in actionItem.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(approvedByItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(actionItem.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in actionItem.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(actionItem.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(actionItem.ClassKind.ToString()); + writer.WritePropertyName("closeOutDate"u8); + + if(actionItem.CloseOutDate.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(actionItem.CloseOutDate.Value.ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("closeOutStatement"u8); + writer.WriteStringValue(actionItem.CloseOutStatement); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(actionItem.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(actionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); - writer.WritePropertyName("owner"u8); - - if(value != null) + foreach(var discussionItem in actionItem.Discussion.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(discussionItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("dueDate"u8); + writer.WriteStringValue(actionItem.DueDate.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in actionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "primaryannotatedthing": - if(!AllowedVersionsPerProperty["primaryAnnotatedThing"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in actionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(actionItem.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(actionItem.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(actionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(actionItem.Owner); writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(value != null) + + if(actionItem.PrimaryAnnotatedThing.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(actionItem.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "relatedthing": - if(!AllowedVersionsPerProperty["relatedThing"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in actionItem.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); } - writer.WriteStartArray("relatedThing"u8); + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(actionItem.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(actionItem.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); - if(value is IEnumerable objectListRelatedThing) + foreach(var sourceAnnotationItem in actionItem.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } + writer.WriteStringValue(sourceAnnotationItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(actionItem.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(actionItem.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(actionItem.Title); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ActionItem for Version 1.3.0"); + writer.WritePropertyName("actionee"u8); + writer.WriteStringValue(actionItem.Actionee); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(actionItem.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(actionItem.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in actionItem.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(actionItem.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in actionItem.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(actionItem.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(actionItem.ClassKind.ToString()); + writer.WritePropertyName("closeOutDate"u8); + + if(actionItem.CloseOutDate.HasValue) + { + writer.WriteStringValue(actionItem.CloseOutDate.Value.ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - break; - case "sourceannotation": - if(!AllowedVersionsPerProperty["sourceAnnotation"].Contains(requestedVersion)) + writer.WritePropertyName("closeOutStatement"u8); + writer.WriteStringValue(actionItem.CloseOutStatement); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(actionItem.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(actionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in actionItem.Discussion.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(discussionItem); } - writer.WriteStartArray("sourceAnnotation"u8); + writer.WriteEndArray(); + writer.WritePropertyName("dueDate"u8); + writer.WriteStringValue(actionItem.DueDate.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListSourceAnnotation) + foreach(var excludedDomainItem in actionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sourceAnnotationItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "status": - if(!AllowedVersionsPerProperty["status"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("excludedPerson"u8); - writer.WritePropertyName("status"u8); - - if(value != null) - { - writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); - } - else + foreach(var excludedPersonItem in actionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(actionItem.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(actionItem.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(actionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(actionItem.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + if(actionItem.PrimaryAnnotatedThing.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(actionItem.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "title": - if(!AllowedVersionsPerProperty["title"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("relatedThing"u8); - writer.WritePropertyName("title"u8); - - if(value != null) + foreach(var relatedThingItem in actionItem.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(relatedThingItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(actionItem.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(actionItem.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in actionItem.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(sourceAnnotationItem); } + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(actionItem.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(actionItem.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(actionItem.Title); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ActionItem"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actionee", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "actor", new []{ "1.3.0" }}, - { "approvedBy", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classification", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "closeOutDate", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "closeOutStatement", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "discussion", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "dueDate", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "primaryAnnotatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "relatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "sourceAnnotation", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "status", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "title", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ActualFiniteStateListSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ActualFiniteStateListSerializer.cs index b111405a..c7484c13 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ActualFiniteStateListSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ActualFiniteStateListSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,6 +49,328 @@ namespace CDP4JsonSerializer /// public class ActualFiniteStateListSerializer : BaseThingSerializer, IThingSerializer { + /// + /// Serialize a value for a property into a + /// + /// The name of the property to serialize + /// The object value to serialize + /// The + /// The that has been requested for the serialization + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + var requestedVersion = requestedDataModelVersion.ToString(3); + + switch(propertyName.ToLower()) + { + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "actualstate": + var allowedVersionsForActualState = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForActualState.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("actualState"u8); + + if(value is IEnumerable objectListActualState) + { + foreach(var actualStateItem in objectListActualState.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(actualStateItem); + } + } + + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("classKind"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } + + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + + writer.WriteEndArray(); + break; + case "excludeoption": + var allowedVersionsForExcludeOption = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludeOption.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludeOption"u8); + + if(value is IEnumerable objectListExcludeOption) + { + foreach(var excludeOptionItem in objectListExcludeOption.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludeOptionItem); + } + } + + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "owner": + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("owner"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "possiblefinitestatelist": + var allowedVersionsForPossibleFiniteStateList = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPossibleFiniteStateList.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("possibleFiniteStateList"u8); + + if(value is IEnumerable objectListPossibleFiniteStateList) + { + foreach(var possibleFiniteStateListItem in objectListPossibleFiniteStateList.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(possibleFiniteStateListItem); + } + } + + writer.WriteEndArray(); + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ActualFiniteStateList"); + } + } + /// /// Serializes a into an /// @@ -76,7 +397,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM switch(requestedDataModelVersion.ToString(3)) { case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ActualFiniteStateList for Version 1.0.0"); + Logger.Log(LogLevel.Debug, "Serializing ActualFiniteStateList for Version 1.0.0"); writer.WriteStartArray("actualState"u8); foreach(var actualStateItem in actualFiniteStateList.ActualState.OrderBy(x => x, this.GuidComparer)) @@ -85,7 +406,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(actualFiniteStateList.ClassKind.ToString()); writer.WriteStartArray("excludeOption"u8); @@ -96,7 +416,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(actualFiniteStateList.Iid); writer.WritePropertyName("owner"u8); @@ -109,12 +428,11 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(actualFiniteStateList.RevisionNumber); break; case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ActualFiniteStateList for Version 1.1.0"); + Logger.Log(LogLevel.Debug, "Serializing ActualFiniteStateList for Version 1.1.0"); writer.WriteStartArray("actualState"u8); foreach(var actualStateItem in actualFiniteStateList.ActualState.OrderBy(x => x, this.GuidComparer)) @@ -123,7 +441,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(actualFiniteStateList.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -134,7 +451,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in actualFiniteStateList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -143,7 +459,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludeOption"u8); foreach(var excludeOptionItem in actualFiniteStateList.ExcludeOption.OrderBy(x => x, this.GuidComparer)) @@ -152,7 +467,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(actualFiniteStateList.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -167,12 +481,11 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(actualFiniteStateList.RevisionNumber); break; case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ActualFiniteStateList for Version 1.2.0"); + Logger.Log(LogLevel.Debug, "Serializing ActualFiniteStateList for Version 1.2.0"); writer.WriteStartArray("actualState"u8); foreach(var actualStateItem in actualFiniteStateList.ActualState.OrderBy(x => x, this.GuidComparer)) @@ -181,7 +494,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(actualFiniteStateList.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -192,7 +504,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in actualFiniteStateList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -201,7 +512,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludeOption"u8); foreach(var excludeOptionItem in actualFiniteStateList.ExcludeOption.OrderBy(x => x, this.GuidComparer)) @@ -210,7 +520,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(actualFiniteStateList.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -225,14 +534,13 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(actualFiniteStateList.RevisionNumber); writer.WritePropertyName("thingPreference"u8); writer.WriteStringValue(actualFiniteStateList.ThingPreference); break; case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ActualFiniteStateList for Version 1.3.0"); + Logger.Log(LogLevel.Debug, "Serializing ActualFiniteStateList for Version 1.3.0"); writer.WritePropertyName("actor"u8); if(actualFiniteStateList.Actor.HasValue) @@ -252,7 +560,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(actualFiniteStateList.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -263,7 +570,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in actualFiniteStateList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -272,7 +578,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludeOption"u8); foreach(var excludeOptionItem in actualFiniteStateList.ExcludeOption.OrderBy(x => x, this.GuidComparer)) @@ -281,7 +586,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(actualFiniteStateList.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -296,7 +600,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(actualFiniteStateList.RevisionNumber); writer.WritePropertyName("thingPreference"u8); @@ -308,260 +611,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteEndObject(); } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "actualstate": - if(!AllowedVersionsPerProperty["actualState"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("actualState"u8); - - if(value is IEnumerable objectListActualState) - { - foreach(var actualStateItem in objectListActualState.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(actualStateItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeoption": - if(!AllowedVersionsPerProperty["excludeOption"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludeOption"u8); - - if(value is IEnumerable objectListExcludeOption) - { - foreach(var excludeOptionItem in objectListExcludeOption.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludeOptionItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("owner"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "possiblefinitestatelist": - if(!AllowedVersionsPerProperty["possibleFiniteStateList"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("possibleFiniteStateList"u8); - - if(value is IEnumerable objectListPossibleFiniteStateList) - { - foreach(var possibleFiniteStateListItem in objectListPossibleFiniteStateList.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(possibleFiniteStateListItem); - } - } - - writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ActualFiniteStateList"); - } - } - - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "actualState", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludeOption", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "possibleFiniteStateList", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ActualFiniteStateSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ActualFiniteStateSerializer.cs index f5addebc..0f93c24d 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ActualFiniteStateSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ActualFiniteStateSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,193 +49,6 @@ namespace CDP4JsonSerializer /// public class ActualFiniteStateSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ActualFiniteState actualFiniteState) - { - throw new ArgumentException("The thing shall be a ActualFiniteState", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ActualFiniteState since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ActualFiniteState for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(actualFiniteState.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(actualFiniteState.Iid); - writer.WritePropertyName("kind"u8); - writer.WriteStringValue(actualFiniteState.Kind.ToString()); - writer.WriteStartArray("possibleState"u8); - - foreach(var possibleStateItem in actualFiniteState.PossibleState.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(possibleStateItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(actualFiniteState.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ActualFiniteState for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(actualFiniteState.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in actualFiniteState.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in actualFiniteState.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(actualFiniteState.Iid); - writer.WritePropertyName("kind"u8); - writer.WriteStringValue(actualFiniteState.Kind.ToString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(actualFiniteState.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("possibleState"u8); - - foreach(var possibleStateItem in actualFiniteState.PossibleState.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(possibleStateItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(actualFiniteState.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ActualFiniteState for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(actualFiniteState.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in actualFiniteState.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in actualFiniteState.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(actualFiniteState.Iid); - writer.WritePropertyName("kind"u8); - writer.WriteStringValue(actualFiniteState.Kind.ToString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(actualFiniteState.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("possibleState"u8); - - foreach(var possibleStateItem in actualFiniteState.PossibleState.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(possibleStateItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(actualFiniteState.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(actualFiniteState.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ActualFiniteState for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(actualFiniteState.Actor.HasValue) - { - writer.WriteStringValue(actualFiniteState.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(actualFiniteState.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in actualFiniteState.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in actualFiniteState.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(actualFiniteState.Iid); - writer.WritePropertyName("kind"u8); - writer.WriteStringValue(actualFiniteState.Kind.ToString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(actualFiniteState.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("possibleState"u8); - - foreach(var possibleStateItem in actualFiniteState.PossibleState.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(possibleStateItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(actualFiniteState.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(actualFiniteState.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -244,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -252,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -270,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -288,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -306,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -324,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -342,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "kind": - if(!AllowedVersionsPerProperty["kind"].Contains(requestedVersion)) + var allowedVersionsForKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForKind.Contains(requestedVersion)) { return; } @@ -360,7 +214,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -378,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "possiblestate": - if(!AllowedVersionsPerProperty["possibleState"].Contains(requestedVersion)) + var allowedVersionsForPossibleState = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPossibleState.Contains(requestedVersion)) { return; } @@ -396,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -414,7 +291,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -437,21 +320,181 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "kind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "possibleState", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not ActualFiniteState actualFiniteState) + { + throw new ArgumentException("The thing shall be a ActualFiniteState", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ActualFiniteState since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ActualFiniteState for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(actualFiniteState.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(actualFiniteState.Iid); + writer.WritePropertyName("kind"u8); + writer.WriteStringValue(actualFiniteState.Kind.ToString()); + writer.WriteStartArray("possibleState"u8); + + foreach(var possibleStateItem in actualFiniteState.PossibleState.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(possibleStateItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(actualFiniteState.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ActualFiniteState for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(actualFiniteState.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in actualFiniteState.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in actualFiniteState.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(actualFiniteState.Iid); + writer.WritePropertyName("kind"u8); + writer.WriteStringValue(actualFiniteState.Kind.ToString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(actualFiniteState.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("possibleState"u8); + + foreach(var possibleStateItem in actualFiniteState.PossibleState.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(possibleStateItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(actualFiniteState.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ActualFiniteState for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(actualFiniteState.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in actualFiniteState.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in actualFiniteState.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(actualFiniteState.Iid); + writer.WritePropertyName("kind"u8); + writer.WriteStringValue(actualFiniteState.Kind.ToString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(actualFiniteState.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("possibleState"u8); + + foreach(var possibleStateItem in actualFiniteState.PossibleState.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(possibleStateItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(actualFiniteState.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(actualFiniteState.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ActualFiniteState for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(actualFiniteState.Actor.HasValue) + { + writer.WriteStringValue(actualFiniteState.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(actualFiniteState.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in actualFiniteState.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in actualFiniteState.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(actualFiniteState.Iid); + writer.WritePropertyName("kind"u8); + writer.WriteStringValue(actualFiniteState.Kind.ToString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(actualFiniteState.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("possibleState"u8); + + foreach(var possibleStateItem in actualFiniteState.PossibleState.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(possibleStateItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(actualFiniteState.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(actualFiniteState.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/AliasSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/AliasSerializer.cs index f9f993a0..250910db 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/AliasSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/AliasSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,173 +49,6 @@ namespace CDP4JsonSerializer /// public class AliasSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Alias alias) - { - throw new ArgumentException("The thing shall be a Alias", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Alias since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Alias for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(alias.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(alias.Content); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(alias.Iid); - writer.WritePropertyName("isSynonym"u8); - writer.WriteBooleanValue(alias.IsSynonym); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(alias.LanguageCode); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(alias.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Alias for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(alias.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(alias.Content); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in alias.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in alias.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(alias.Iid); - writer.WritePropertyName("isSynonym"u8); - writer.WriteBooleanValue(alias.IsSynonym); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(alias.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(alias.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(alias.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Alias for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(alias.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(alias.Content); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in alias.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in alias.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(alias.Iid); - writer.WritePropertyName("isSynonym"u8); - writer.WriteBooleanValue(alias.IsSynonym); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(alias.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(alias.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(alias.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(alias.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Alias for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(alias.Actor.HasValue) - { - writer.WriteStringValue(alias.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(alias.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(alias.Content); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in alias.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in alias.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(alias.Iid); - writer.WritePropertyName("isSynonym"u8); - writer.WriteBooleanValue(alias.IsSynonym); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(alias.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(alias.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(alias.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(alias.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -224,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -232,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -250,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -268,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + var allowedVersionsForContent = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContent.Contains(requestedVersion)) { return; } @@ -286,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -304,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -322,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -340,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "issynonym": - if(!AllowedVersionsPerProperty["isSynonym"].Contains(requestedVersion)) + var allowedVersionsForIsSynonym = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsSynonym.Contains(requestedVersion)) { return; } @@ -358,7 +240,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + var allowedVersionsForLanguageCode = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } @@ -376,7 +266,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -394,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -412,7 +317,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -435,22 +346,165 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isSynonym", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Alias alias) + { + throw new ArgumentException("The thing shall be a Alias", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Alias since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Alias for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(alias.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(alias.Content); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(alias.Iid); + writer.WritePropertyName("isSynonym"u8); + writer.WriteBooleanValue(alias.IsSynonym); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(alias.LanguageCode); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(alias.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Alias for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(alias.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(alias.Content); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in alias.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in alias.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(alias.Iid); + writer.WritePropertyName("isSynonym"u8); + writer.WriteBooleanValue(alias.IsSynonym); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(alias.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(alias.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(alias.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Alias for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(alias.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(alias.Content); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in alias.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in alias.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(alias.Iid); + writer.WritePropertyName("isSynonym"u8); + writer.WriteBooleanValue(alias.IsSynonym); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(alias.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(alias.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(alias.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(alias.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Alias for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(alias.Actor.HasValue) + { + writer.WriteStringValue(alias.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(alias.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(alias.Content); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in alias.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in alias.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(alias.Iid); + writer.WritePropertyName("isSynonym"u8); + writer.WriteBooleanValue(alias.IsSynonym); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(alias.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(alias.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(alias.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(alias.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/AndExpressionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/AndExpressionSerializer.cs index cba482db..6b7bbe8a 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/AndExpressionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/AndExpressionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,185 +49,6 @@ namespace CDP4JsonSerializer /// public class AndExpressionSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not AndExpression andExpression) - { - throw new ArgumentException("The thing shall be a AndExpression", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of AndExpression since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing AndExpression for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(andExpression.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(andExpression.Iid); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(andExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in andExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing AndExpression for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(andExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in andExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in andExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(andExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(andExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(andExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in andExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing AndExpression for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(andExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in andExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in andExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(andExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(andExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(andExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in andExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(andExpression.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing AndExpression for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(andExpression.Actor.HasValue) - { - writer.WriteStringValue(andExpression.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(andExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in andExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in andExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(andExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(andExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(andExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in andExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(andExpression.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -236,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -244,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -262,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -280,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -298,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -316,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -334,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -352,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -370,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "term": - if(!AllowedVersionsPerProperty["term"].Contains(requestedVersion)) + var allowedVersionsForTerm = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTerm.Contains(requestedVersion)) { return; } @@ -388,7 +265,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -411,20 +294,173 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "term", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not AndExpression andExpression) + { + throw new ArgumentException("The thing shall be a AndExpression", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of AndExpression since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing AndExpression for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(andExpression.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(andExpression.Iid); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(andExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in andExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing AndExpression for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(andExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in andExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in andExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(andExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(andExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(andExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in andExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing AndExpression for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(andExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in andExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in andExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(andExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(andExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(andExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in andExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(andExpression.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing AndExpression for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(andExpression.Actor.HasValue) + { + writer.WriteStringValue(andExpression.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(andExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in andExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in andExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(andExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(andExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(andExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in andExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(andExpression.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ApprovalSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ApprovalSerializer.cs index c05f4dd9..39477bf3 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ApprovalSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ApprovalSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,176 +49,6 @@ namespace CDP4JsonSerializer /// public class ApprovalSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Approval approval) - { - throw new ArgumentException("The thing shall be a Approval", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Approval since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Approval for Version 1.1.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(approval.Author); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(approval.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(approval.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(approval.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(approval.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in approval.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in approval.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(approval.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(approval.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(approval.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(approval.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(approval.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Approval for Version 1.2.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(approval.Author); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(approval.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(approval.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(approval.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(approval.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in approval.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in approval.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(approval.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(approval.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(approval.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(approval.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(approval.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(approval.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Approval for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(approval.Actor.HasValue) - { - writer.WriteStringValue(approval.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(approval.Author); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(approval.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(approval.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(approval.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(approval.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in approval.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in approval.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(approval.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(approval.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(approval.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(approval.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(approval.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(approval.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -227,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -235,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -253,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { return; } @@ -271,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classification": - if(!AllowedVersionsPerProperty["classification"].Contains(requestedVersion)) + var allowedVersionsForClassification = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassification.Contains(requestedVersion)) { return; } @@ -289,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -307,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContent.Contains(requestedVersion)) { return; } @@ -325,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -343,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -361,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -379,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -397,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + var allowedVersionsForLanguageCode = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } @@ -415,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -433,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -451,7 +361,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -469,7 +386,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -492,25 +415,168 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classification", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Approval approval) + { + throw new ArgumentException("The thing shall be a Approval", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Approval since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Approval for Version 1.1.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(approval.Author); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(approval.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(approval.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(approval.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(approval.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in approval.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in approval.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(approval.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(approval.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(approval.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(approval.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(approval.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Approval for Version 1.2.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(approval.Author); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(approval.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(approval.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(approval.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(approval.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in approval.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in approval.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(approval.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(approval.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(approval.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(approval.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(approval.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(approval.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Approval for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(approval.Actor.HasValue) + { + writer.WriteStringValue(approval.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("author"u8); + writer.WriteStringValue(approval.Author); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(approval.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(approval.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(approval.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(approval.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in approval.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in approval.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(approval.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(approval.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(approval.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(approval.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(approval.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(approval.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ArrayParameterTypeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ArrayParameterTypeSerializer.cs index 99a8b199..ee7e3e43 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ArrayParameterTypeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ArrayParameterTypeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,437 +50,395 @@ namespace CDP4JsonSerializer public class ArrayParameterTypeSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ArrayParameterType arrayParameterType) - { - throw new ArgumentException("The thing shall be a ArrayParameterType", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ArrayParameterType since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ArrayParameterType for Version 1.0.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in arrayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + case "actor": + var allowedVersionsForActor = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + "1.3.0", + }; - foreach(var categoryItem in arrayParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(arrayParameterType.ClassKind.ToString()); - writer.WriteStartArray("component"u8); - - foreach(var componentItem in arrayParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) + if(value != null) { - writer.WriteOrderedItem(componentItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in arrayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("dimension"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var dimensionItem in arrayParameterType.Dimension.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteOrderedItem(dimensionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in arrayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(arrayParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(arrayParameterType.IsDeprecated); - writer.WritePropertyName("isFinalized"u8); - writer.WriteBooleanValue(arrayParameterType.IsFinalized); - writer.WritePropertyName("isTensor"u8); - writer.WriteBooleanValue(arrayParameterType.IsTensor); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(arrayParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(arrayParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(arrayParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(arrayParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ArrayParameterType for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in arrayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in arrayParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(arrayParameterType.ClassKind.ToString()); - writer.WriteStartArray("component"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var componentItem in arrayParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteOrderedItem(componentItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in arrayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("dimension"u8); + break; + case "component": + var allowedVersionsForComponent = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var dimensionItem in arrayParameterType.Dimension.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForComponent.Contains(requestedVersion)) { - writer.WriteOrderedItem(dimensionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("component"u8); - foreach(var excludedDomainItem in arrayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListComponent) { - writer.WriteStringValue(excludedDomainItem); + foreach(var componentItem in objectListComponent.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(componentItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in arrayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in arrayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(arrayParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(arrayParameterType.IsDeprecated); - writer.WritePropertyName("isFinalized"u8); - writer.WriteBooleanValue(arrayParameterType.IsFinalized); - writer.WritePropertyName("isTensor"u8); - writer.WriteBooleanValue(arrayParameterType.IsTensor); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(arrayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(arrayParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(arrayParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(arrayParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(arrayParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ArrayParameterType for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "dimension": + var allowedVersionsForDimension = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in arrayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDimension.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("dimension"u8); - foreach(var categoryItem in arrayParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDimension) { - writer.WriteStringValue(categoryItem); + foreach(var dimensionItem in objectListDimension.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(dimensionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(arrayParameterType.ClassKind.ToString()); - writer.WriteStartArray("component"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var componentItem in arrayParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteOrderedItem(componentItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in arrayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("dimension"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var dimensionItem in arrayParameterType.Dimension.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteOrderedItem(dimensionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in arrayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in arrayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in arrayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(arrayParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(arrayParameterType.IsDeprecated); - writer.WritePropertyName("isFinalized"u8); - writer.WriteBooleanValue(arrayParameterType.IsFinalized); - writer.WritePropertyName("isTensor"u8); - writer.WriteBooleanValue(arrayParameterType.IsTensor); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(arrayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(arrayParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(arrayParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(arrayParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(arrayParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(arrayParameterType.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ArrayParameterType for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(arrayParameterType.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(arrayParameterType.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in arrayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in arrayParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(arrayParameterType.ClassKind.ToString()); - writer.WriteStartArray("component"u8); - - foreach(var componentItem in arrayParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) + else { - writer.WriteOrderedItem(componentItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("definition"u8); + break; + case "isfinalized": + var allowedVersionsForIsFinalized = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in arrayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsFinalized.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isFinalized"u8); - writer.WriteStartArray("dimension"u8); - - foreach(var dimensionItem in arrayParameterType.Dimension.OrderBy(x => x, this.OrderedItemComparer)) + if(value != null) { - writer.WriteOrderedItem(dimensionItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in arrayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "istensor": + var allowedVersionsForIsTensor = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in arrayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsTensor.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isTensor"u8); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in arrayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(arrayParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(arrayParameterType.IsDeprecated); - writer.WritePropertyName("isFinalized"u8); - writer.WriteBooleanValue(arrayParameterType.IsFinalized); - writer.WritePropertyName("isTensor"u8); - writer.WriteBooleanValue(arrayParameterType.IsTensor); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(arrayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(arrayParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(arrayParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(arrayParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(arrayParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(arrayParameterType.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -489,53 +446,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) + if(!allowedVersionsForName.Contains(requestedVersion)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + return; } + + writer.WritePropertyName("name"u8); - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + else { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -543,325 +498,463 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "component": - if(!AllowedVersionsPerProperty["component"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("component"u8); - - if(value is IEnumerable objectListComponent) + writer.WritePropertyName("shortName"u8); + + if(value != null) { - foreach(var componentItem in objectListComponent.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(componentItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("definition"u8); + break; + case "symbol": + var allowedVersionsForSymbol = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDefinition) + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + return; } + + writer.WritePropertyName("symbol"u8); - writer.WriteEndArray(); - break; - case "dimension": - if(!AllowedVersionsPerProperty["dimension"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("dimension"u8); - - if(value is IEnumerable objectListDimension) + else { - foreach(var dimensionItem in objectListDimension.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(dimensionItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedPerson"u8); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ArrayParameterType"); + } + } - if(value is IEnumerable objectListExcludedPerson) + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ArrayParameterType arrayParameterType) + { + throw new ArgumentException("The thing shall be a ArrayParameterType", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ArrayParameterType since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ArrayParameterType for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in arrayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in arrayParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(arrayParameterType.ClassKind.ToString()); + writer.WriteStartArray("component"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var componentItem in arrayParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteOrderedItem(componentItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in arrayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("dimension"u8); + + foreach(var dimensionItem in arrayParameterType.Dimension.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteOrderedItem(dimensionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in arrayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(arrayParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(arrayParameterType.IsDeprecated); + writer.WritePropertyName("isFinalized"u8); + writer.WriteBooleanValue(arrayParameterType.IsFinalized); + writer.WritePropertyName("isTensor"u8); + writer.WriteBooleanValue(arrayParameterType.IsTensor); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(arrayParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(arrayParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(arrayParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(arrayParameterType.Symbol); break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ArrayParameterType for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in arrayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in arrayParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(arrayParameterType.ClassKind.ToString()); + writer.WriteStartArray("component"u8); + + foreach(var componentItem in arrayParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(componentItem); } - break; - case "isfinalized": - if(!AllowedVersionsPerProperty["isFinalized"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in arrayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("isFinalized"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("dimension"u8); + + foreach(var dimensionItem in arrayParameterType.Dimension.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteOrderedItem(dimensionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in arrayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "istensor": - if(!AllowedVersionsPerProperty["isTensor"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in arrayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("isTensor"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in arrayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(arrayParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(arrayParameterType.IsDeprecated); + writer.WritePropertyName("isFinalized"u8); + writer.WriteBooleanValue(arrayParameterType.IsFinalized); + writer.WritePropertyName("isTensor"u8); + writer.WriteBooleanValue(arrayParameterType.IsTensor); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(arrayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(arrayParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(arrayParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(arrayParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(arrayParameterType.Symbol); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ArrayParameterType for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in arrayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(aliasItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in arrayParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(arrayParameterType.ClassKind.ToString()); + writer.WriteStartArray("component"u8); + + foreach(var componentItem in arrayParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteOrderedItem(componentItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in arrayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("dimension"u8); + + foreach(var dimensionItem in arrayParameterType.Dimension.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(dimensionItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in arrayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in arrayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in arrayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(arrayParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(arrayParameterType.IsDeprecated); + writer.WritePropertyName("isFinalized"u8); + writer.WriteBooleanValue(arrayParameterType.IsFinalized); + writer.WritePropertyName("isTensor"u8); + writer.WriteBooleanValue(arrayParameterType.IsTensor); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(arrayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(arrayParameterType.Name); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(arrayParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(arrayParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(arrayParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(arrayParameterType.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ArrayParameterType for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(arrayParameterType.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(arrayParameterType.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) + foreach(var aliasItem in arrayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in arrayParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(arrayParameterType.ClassKind.ToString()); + writer.WriteStartArray("component"u8); + + foreach(var componentItem in arrayParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(componentItem); } - writer.WritePropertyName("symbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in arrayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("dimension"u8); + + foreach(var dimensionItem in arrayParameterType.Dimension.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(dimensionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in arrayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in arrayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in arrayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(arrayParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(arrayParameterType.IsDeprecated); + writer.WritePropertyName("isFinalized"u8); + writer.WriteBooleanValue(arrayParameterType.IsFinalized); + writer.WritePropertyName("isTensor"u8); + writer.WriteBooleanValue(arrayParameterType.IsTensor); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(arrayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(arrayParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(arrayParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(arrayParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(arrayParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(arrayParameterType.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ArrayParameterType"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "component", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "dimension", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isFinalized", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isTensor", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryNoteSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryNoteSerializer.cs index 4547107d..d908fa88 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryNoteSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryNoteSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,203 +49,6 @@ namespace CDP4JsonSerializer /// public class BinaryNoteSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not BinaryNote binaryNote) - { - throw new ArgumentException("The thing shall be a BinaryNote", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of BinaryNote since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing BinaryNote for Version 1.1.0"); - writer.WritePropertyName("caption"u8); - writer.WriteStringValue(binaryNote.Caption); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in binaryNote.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(binaryNote.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(binaryNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in binaryNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in binaryNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("fileType"u8); - writer.WriteStringValue(binaryNote.FileType); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(binaryNote.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(binaryNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(binaryNote.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(binaryNote.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(binaryNote.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(binaryNote.ShortName); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing BinaryNote for Version 1.2.0"); - writer.WritePropertyName("caption"u8); - writer.WriteStringValue(binaryNote.Caption); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in binaryNote.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(binaryNote.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(binaryNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in binaryNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in binaryNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("fileType"u8); - writer.WriteStringValue(binaryNote.FileType); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(binaryNote.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(binaryNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(binaryNote.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(binaryNote.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(binaryNote.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(binaryNote.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(binaryNote.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing BinaryNote for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(binaryNote.Actor.HasValue) - { - writer.WriteStringValue(binaryNote.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("caption"u8); - writer.WriteStringValue(binaryNote.Caption); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in binaryNote.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(binaryNote.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(binaryNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in binaryNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in binaryNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("fileType"u8); - writer.WriteStringValue(binaryNote.FileType); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(binaryNote.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(binaryNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(binaryNote.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(binaryNote.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(binaryNote.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(binaryNote.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(binaryNote.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -254,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -262,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -280,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "caption": - if(!AllowedVersionsPerProperty["caption"].Contains(requestedVersion)) + var allowedVersionsForCaption = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCaption.Contains(requestedVersion)) { return; } @@ -298,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) { return; } @@ -316,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -334,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -352,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -370,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -388,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "filetype": - if(!AllowedVersionsPerProperty["fileType"].Contains(requestedVersion)) + var allowedVersionsForFileType = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFileType.Contains(requestedVersion)) { return; } @@ -406,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -424,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -442,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -460,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -478,7 +361,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -496,7 +386,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -514,7 +411,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -537,26 +440,192 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "caption", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fileType", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not BinaryNote binaryNote) + { + throw new ArgumentException("The thing shall be a BinaryNote", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of BinaryNote since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing BinaryNote for Version 1.1.0"); + writer.WritePropertyName("caption"u8); + writer.WriteStringValue(binaryNote.Caption); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in binaryNote.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(binaryNote.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(binaryNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in binaryNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in binaryNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("fileType"u8); + writer.WriteStringValue(binaryNote.FileType); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(binaryNote.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(binaryNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(binaryNote.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(binaryNote.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(binaryNote.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(binaryNote.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing BinaryNote for Version 1.2.0"); + writer.WritePropertyName("caption"u8); + writer.WriteStringValue(binaryNote.Caption); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in binaryNote.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(binaryNote.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(binaryNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in binaryNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in binaryNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("fileType"u8); + writer.WriteStringValue(binaryNote.FileType); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(binaryNote.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(binaryNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(binaryNote.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(binaryNote.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(binaryNote.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(binaryNote.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(binaryNote.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing BinaryNote for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(binaryNote.Actor.HasValue) + { + writer.WriteStringValue(binaryNote.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("caption"u8); + writer.WriteStringValue(binaryNote.Caption); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in binaryNote.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(binaryNote.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(binaryNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in binaryNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in binaryNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("fileType"u8); + writer.WriteStringValue(binaryNote.FileType); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(binaryNote.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(binaryNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(binaryNote.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(binaryNote.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(binaryNote.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(binaryNote.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(binaryNote.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryRelationshipRuleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryRelationshipRuleSerializer.cs index 79fbf331..68c5bc3e 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryRelationshipRuleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryRelationshipRuleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,345 +50,266 @@ namespace CDP4JsonSerializer public class BinaryRelationshipRuleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not BinaryRelationshipRule binaryRelationshipRule) - { - throw new ArgumentException("The thing shall be a BinaryRelationshipRule", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of BinaryRelationshipRule since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing BinaryRelationshipRule for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in binaryRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(binaryRelationshipRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in binaryRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("forwardRelationshipName"u8); - writer.WriteStringValue(binaryRelationshipRule.ForwardRelationshipName); - writer.WriteStartArray("hyperLink"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in binaryRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(binaryRelationshipRule.Iid); - writer.WritePropertyName("inverseRelationshipName"u8); - writer.WriteStringValue(binaryRelationshipRule.InverseRelationshipName); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(binaryRelationshipRule.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(binaryRelationshipRule.Name); - writer.WritePropertyName("relationshipCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.RelationshipCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(binaryRelationshipRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(binaryRelationshipRule.ShortName); - writer.WritePropertyName("sourceCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.SourceCategory); - writer.WritePropertyName("targetCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.TargetCategory); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing BinaryRelationshipRule for Version 1.1.0"); writer.WriteStartArray("alias"u8); - foreach(var aliasItem in binaryRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(aliasItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(binaryRelationshipRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in binaryRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in binaryRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in binaryRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("forwardRelationshipName"u8); - writer.WriteStringValue(binaryRelationshipRule.ForwardRelationshipName); - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in binaryRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(binaryRelationshipRule.Iid); - writer.WritePropertyName("inverseRelationshipName"u8); - writer.WriteStringValue(binaryRelationshipRule.InverseRelationshipName); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(binaryRelationshipRule.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(binaryRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(binaryRelationshipRule.Name); - writer.WritePropertyName("relationshipCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.RelationshipCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(binaryRelationshipRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(binaryRelationshipRule.ShortName); - writer.WritePropertyName("sourceCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.SourceCategory); - writer.WritePropertyName("targetCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.TargetCategory); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing BinaryRelationshipRule for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in binaryRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(binaryRelationshipRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in binaryRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in binaryRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in binaryRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("forwardRelationshipName"u8); - writer.WriteStringValue(binaryRelationshipRule.ForwardRelationshipName); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "forwardrelationshipname": + var allowedVersionsForForwardRelationshipName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in binaryRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForForwardRelationshipName.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("forwardRelationshipName"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(binaryRelationshipRule.Iid); - writer.WritePropertyName("inverseRelationshipName"u8); - writer.WriteStringValue(binaryRelationshipRule.InverseRelationshipName); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(binaryRelationshipRule.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(binaryRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(binaryRelationshipRule.Name); - writer.WritePropertyName("relationshipCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.RelationshipCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(binaryRelationshipRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(binaryRelationshipRule.ShortName); - writer.WritePropertyName("sourceCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.SourceCategory); - writer.WritePropertyName("targetCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.TargetCategory); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(binaryRelationshipRule.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing BinaryRelationshipRule for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(binaryRelationshipRule.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(binaryRelationshipRule.Actor.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in binaryRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(binaryRelationshipRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var definitionItem in binaryRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in binaryRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in binaryRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("forwardRelationshipName"u8); - writer.WriteStringValue(binaryRelationshipRule.ForwardRelationshipName); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in binaryRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(binaryRelationshipRule.Iid); - writer.WritePropertyName("inverseRelationshipName"u8); - writer.WriteStringValue(binaryRelationshipRule.InverseRelationshipName); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(binaryRelationshipRule.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(binaryRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(binaryRelationshipRule.Name); - writer.WritePropertyName("relationshipCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.RelationshipCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(binaryRelationshipRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(binaryRelationshipRule.ShortName); - writer.WritePropertyName("sourceCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.SourceCategory); - writer.WritePropertyName("targetCategory"u8); - writer.WriteStringValue(binaryRelationshipRule.TargetCategory); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(binaryRelationshipRule.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "inverserelationshipname": + var allowedVersionsForInverseRelationshipName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForInverseRelationshipName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("inverseRelationshipName"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -397,35 +317,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("isDeprecated"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteBooleanValue((bool)value); } else { @@ -433,67 +343,46 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List { - return; - } - - writer.WriteStartArray("definition"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } + writer.WritePropertyName("modifiedOn"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "forwardrelationshipname": - if(!AllowedVersionsPerProperty["forwardRelationshipName"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("forwardRelationshipName"u8); + writer.WritePropertyName("name"u8); if(value != null) { @@ -505,31 +394,21 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "relationshipcategory": + var allowedVersionsForRelationshipCategory = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForRelationshipCategory.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("relationshipCategory"u8); if(value != null) { @@ -541,17 +420,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "inverserelationshipname": - if(!AllowedVersionsPerProperty["inverseRelationshipName"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("inverseRelationshipName"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue((int)value); } else { @@ -559,17 +446,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isDeprecated"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -577,17 +472,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "sourcecategory": + var allowedVersionsForSourceCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSourceCategory.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); + writer.WritePropertyName("sourceCategory"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((Guid)value); } else { @@ -595,17 +498,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + case "targetcategory": + var allowedVersionsForTargetCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTargetCategory.Contains(requestedVersion)) { return; } - writer.WritePropertyName("name"u8); + writer.WritePropertyName("targetCategory"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue((Guid)value); } else { @@ -613,17 +524,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "relationshipcategory": - if(!AllowedVersionsPerProperty["relationshipCategory"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("relationshipCategory"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -631,126 +548,307 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the BinaryRelationshipRule"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not BinaryRelationshipRule binaryRelationshipRule) + { + throw new ArgumentException("The thing shall be a BinaryRelationshipRule", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of BinaryRelationshipRule since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing BinaryRelationshipRule for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in binaryRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(binaryRelationshipRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in binaryRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("forwardRelationshipName"u8); + writer.WriteStringValue(binaryRelationshipRule.ForwardRelationshipName); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in binaryRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(binaryRelationshipRule.Iid); + writer.WritePropertyName("inverseRelationshipName"u8); + writer.WriteStringValue(binaryRelationshipRule.InverseRelationshipName); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(binaryRelationshipRule.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(binaryRelationshipRule.Name); + writer.WritePropertyName("relationshipCategory"u8); + writer.WriteStringValue(binaryRelationshipRule.RelationshipCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(binaryRelationshipRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(binaryRelationshipRule.ShortName); + writer.WritePropertyName("sourceCategory"u8); + writer.WriteStringValue(binaryRelationshipRule.SourceCategory); + writer.WritePropertyName("targetCategory"u8); + writer.WriteStringValue(binaryRelationshipRule.TargetCategory); break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing BinaryRelationshipRule for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in binaryRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(binaryRelationshipRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in binaryRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in binaryRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "sourcecategory": - if(!AllowedVersionsPerProperty["sourceCategory"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in binaryRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("forwardRelationshipName"u8); + writer.WriteStringValue(binaryRelationshipRule.ForwardRelationshipName); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in binaryRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(binaryRelationshipRule.Iid); + writer.WritePropertyName("inverseRelationshipName"u8); + writer.WriteStringValue(binaryRelationshipRule.InverseRelationshipName); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(binaryRelationshipRule.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(binaryRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(binaryRelationshipRule.Name); + writer.WritePropertyName("relationshipCategory"u8); + writer.WriteStringValue(binaryRelationshipRule.RelationshipCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(binaryRelationshipRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(binaryRelationshipRule.ShortName); writer.WritePropertyName("sourceCategory"u8); - - if(value != null) + writer.WriteStringValue(binaryRelationshipRule.SourceCategory); + writer.WritePropertyName("targetCategory"u8); + writer.WriteStringValue(binaryRelationshipRule.TargetCategory); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing BinaryRelationshipRule for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in binaryRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(binaryRelationshipRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in binaryRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "targetcategory": - if(!AllowedVersionsPerProperty["targetCategory"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in binaryRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in binaryRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("forwardRelationshipName"u8); + writer.WriteStringValue(binaryRelationshipRule.ForwardRelationshipName); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in binaryRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(binaryRelationshipRule.Iid); + writer.WritePropertyName("inverseRelationshipName"u8); + writer.WriteStringValue(binaryRelationshipRule.InverseRelationshipName); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(binaryRelationshipRule.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(binaryRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(binaryRelationshipRule.Name); + writer.WritePropertyName("relationshipCategory"u8); + writer.WriteStringValue(binaryRelationshipRule.RelationshipCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(binaryRelationshipRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(binaryRelationshipRule.ShortName); + writer.WritePropertyName("sourceCategory"u8); + writer.WriteStringValue(binaryRelationshipRule.SourceCategory); writer.WritePropertyName("targetCategory"u8); - - if(value != null) + writer.WriteStringValue(binaryRelationshipRule.TargetCategory); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(binaryRelationshipRule.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing BinaryRelationshipRule for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(binaryRelationshipRule.Actor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(binaryRelationshipRule.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in binaryRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(binaryRelationshipRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in binaryRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in binaryRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in binaryRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("forwardRelationshipName"u8); + writer.WriteStringValue(binaryRelationshipRule.ForwardRelationshipName); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in binaryRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(binaryRelationshipRule.Iid); + writer.WritePropertyName("inverseRelationshipName"u8); + writer.WriteStringValue(binaryRelationshipRule.InverseRelationshipName); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(binaryRelationshipRule.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(binaryRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(binaryRelationshipRule.Name); + writer.WritePropertyName("relationshipCategory"u8); + writer.WriteStringValue(binaryRelationshipRule.RelationshipCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(binaryRelationshipRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(binaryRelationshipRule.ShortName); + writer.WritePropertyName("sourceCategory"u8); + writer.WriteStringValue(binaryRelationshipRule.SourceCategory); + writer.WritePropertyName("targetCategory"u8); + writer.WriteStringValue(binaryRelationshipRule.TargetCategory); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(binaryRelationshipRule.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the BinaryRelationshipRule"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "forwardRelationshipName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "inverseRelationshipName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "relationshipCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "sourceCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "targetCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryRelationshipSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryRelationshipSerializer.cs index a719d088..f7c686f7 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryRelationshipSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/BinaryRelationshipSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,240 +49,6 @@ namespace CDP4JsonSerializer /// public class BinaryRelationshipSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not BinaryRelationship binaryRelationship) - { - throw new ArgumentException("The thing shall be a BinaryRelationship", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of BinaryRelationship since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing BinaryRelationship for Version 1.0.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in binaryRelationship.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(binaryRelationship.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(binaryRelationship.Iid); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(binaryRelationship.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(binaryRelationship.RevisionNumber); - writer.WritePropertyName("source"u8); - writer.WriteStringValue(binaryRelationship.Source); - writer.WritePropertyName("target"u8); - writer.WriteStringValue(binaryRelationship.Target); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing BinaryRelationship for Version 1.1.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in binaryRelationship.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(binaryRelationship.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in binaryRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in binaryRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(binaryRelationship.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(binaryRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(binaryRelationship.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in binaryRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterValueItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(binaryRelationship.RevisionNumber); - writer.WritePropertyName("source"u8); - writer.WriteStringValue(binaryRelationship.Source); - writer.WritePropertyName("target"u8); - writer.WriteStringValue(binaryRelationship.Target); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing BinaryRelationship for Version 1.2.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in binaryRelationship.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(binaryRelationship.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in binaryRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in binaryRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(binaryRelationship.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(binaryRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(binaryRelationship.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(binaryRelationship.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in binaryRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterValueItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(binaryRelationship.RevisionNumber); - writer.WritePropertyName("source"u8); - writer.WriteStringValue(binaryRelationship.Source); - writer.WritePropertyName("target"u8); - writer.WriteStringValue(binaryRelationship.Target); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(binaryRelationship.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing BinaryRelationship for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(binaryRelationship.Actor.HasValue) - { - writer.WriteStringValue(binaryRelationship.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in binaryRelationship.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(binaryRelationship.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in binaryRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in binaryRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(binaryRelationship.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(binaryRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(binaryRelationship.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(binaryRelationship.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in binaryRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterValueItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(binaryRelationship.RevisionNumber); - writer.WritePropertyName("source"u8); - writer.WriteStringValue(binaryRelationship.Source); - writer.WritePropertyName("target"u8); - writer.WriteStringValue(binaryRelationship.Target); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(binaryRelationship.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -291,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -299,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -317,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) { return; } @@ -335,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -353,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -371,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -389,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -407,7 +214,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -425,7 +239,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -443,7 +263,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -461,7 +289,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parametervalue": - if(!AllowedVersionsPerProperty["parameterValue"].Contains(requestedVersion)) + var allowedVersionsForParameterValue = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterValue.Contains(requestedVersion)) { return; } @@ -479,7 +314,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -497,7 +340,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "source": - if(!AllowedVersionsPerProperty["source"].Contains(requestedVersion)) + var allowedVersionsForSource = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSource.Contains(requestedVersion)) { return; } @@ -515,7 +366,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "target": - if(!AllowedVersionsPerProperty["target"].Contains(requestedVersion)) + var allowedVersionsForTarget = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTarget.Contains(requestedVersion)) { return; } @@ -533,7 +392,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -556,25 +421,225 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterValue", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "source", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "target", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not BinaryRelationship binaryRelationship) + { + throw new ArgumentException("The thing shall be a BinaryRelationship", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of BinaryRelationship since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing BinaryRelationship for Version 1.0.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in binaryRelationship.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(binaryRelationship.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(binaryRelationship.Iid); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(binaryRelationship.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(binaryRelationship.RevisionNumber); + writer.WritePropertyName("source"u8); + writer.WriteStringValue(binaryRelationship.Source); + writer.WritePropertyName("target"u8); + writer.WriteStringValue(binaryRelationship.Target); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing BinaryRelationship for Version 1.1.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in binaryRelationship.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(binaryRelationship.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in binaryRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in binaryRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(binaryRelationship.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(binaryRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(binaryRelationship.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in binaryRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterValueItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(binaryRelationship.RevisionNumber); + writer.WritePropertyName("source"u8); + writer.WriteStringValue(binaryRelationship.Source); + writer.WritePropertyName("target"u8); + writer.WriteStringValue(binaryRelationship.Target); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing BinaryRelationship for Version 1.2.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in binaryRelationship.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(binaryRelationship.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in binaryRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in binaryRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(binaryRelationship.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(binaryRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(binaryRelationship.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(binaryRelationship.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in binaryRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterValueItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(binaryRelationship.RevisionNumber); + writer.WritePropertyName("source"u8); + writer.WriteStringValue(binaryRelationship.Source); + writer.WritePropertyName("target"u8); + writer.WriteStringValue(binaryRelationship.Target); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(binaryRelationship.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing BinaryRelationship for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(binaryRelationship.Actor.HasValue) + { + writer.WriteStringValue(binaryRelationship.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in binaryRelationship.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(binaryRelationship.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in binaryRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in binaryRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(binaryRelationship.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(binaryRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(binaryRelationship.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(binaryRelationship.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in binaryRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterValueItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(binaryRelationship.RevisionNumber); + writer.WritePropertyName("source"u8); + writer.WriteStringValue(binaryRelationship.Source); + writer.WritePropertyName("target"u8); + writer.WriteStringValue(binaryRelationship.Target); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(binaryRelationship.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/BookSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/BookSerializer.cs index abc6c6d3..55e95e54 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/BookSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/BookSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,218 +49,6 @@ namespace CDP4JsonSerializer /// public class BookSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Book book) - { - throw new ArgumentException("The thing shall be a Book", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Book since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Book for Version 1.1.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in book.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(book.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(book.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in book.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in book.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(book.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(book.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(book.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(book.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(book.RevisionNumber); - writer.WriteStartArray("section"u8); - - foreach(var sectionItem in book.Section.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(sectionItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(book.ShortName); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Book for Version 1.2.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in book.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(book.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(book.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in book.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in book.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(book.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(book.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(book.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(book.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(book.RevisionNumber); - writer.WriteStartArray("section"u8); - - foreach(var sectionItem in book.Section.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(sectionItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(book.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(book.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Book for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(book.Actor.HasValue) - { - writer.WriteStringValue(book.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in book.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(book.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(book.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in book.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in book.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(book.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(book.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(book.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(book.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(book.RevisionNumber); - writer.WriteStartArray("section"u8); - - foreach(var sectionItem in book.Section.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(sectionItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(book.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(book.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -269,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -277,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -295,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) { return; } @@ -313,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -331,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -349,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -367,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -385,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -403,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -421,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -439,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -457,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -475,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "section": - if(!AllowedVersionsPerProperty["section"].Contains(requestedVersion)) + var allowedVersionsForSection = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSection.Contains(requestedVersion)) { return; } @@ -493,7 +361,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -511,7 +386,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -534,25 +415,204 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "section", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Book book) + { + throw new ArgumentException("The thing shall be a Book", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Book since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Book for Version 1.1.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in book.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(book.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(book.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in book.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in book.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(book.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(book.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(book.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(book.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(book.RevisionNumber); + writer.WriteStartArray("section"u8); + + foreach(var sectionItem in book.Section.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(sectionItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(book.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Book for Version 1.2.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in book.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(book.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(book.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in book.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in book.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(book.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(book.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(book.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(book.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(book.RevisionNumber); + writer.WriteStartArray("section"u8); + + foreach(var sectionItem in book.Section.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(sectionItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(book.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(book.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Book for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(book.Actor.HasValue) + { + writer.WriteStringValue(book.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in book.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(book.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(book.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in book.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in book.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(book.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(book.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(book.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(book.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(book.RevisionNumber); + writer.WriteStartArray("section"u8); + + foreach(var sectionItem in book.Section.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(sectionItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(book.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(book.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/BooleanParameterTypeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/BooleanParameterTypeSerializer.cs index 60566d57..8bd6e5c0 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/BooleanParameterTypeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/BooleanParameterTypeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,349 +50,317 @@ namespace CDP4JsonSerializer public class BooleanParameterTypeSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not BooleanParameterType booleanParameterType) - { - throw new ArgumentException("The thing shall be a BooleanParameterType", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of BooleanParameterType since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing BooleanParameterType for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in booleanParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in booleanParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(booleanParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in booleanParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in booleanParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(booleanParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(booleanParameterType.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(booleanParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(booleanParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(booleanParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(booleanParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing BooleanParameterType for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in booleanParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in booleanParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(booleanParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in booleanParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in booleanParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in booleanParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in booleanParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(booleanParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(booleanParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(booleanParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(booleanParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(booleanParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(booleanParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(booleanParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing BooleanParameterType for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in booleanParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in booleanParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(booleanParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in booleanParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in booleanParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in booleanParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in booleanParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(booleanParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(booleanParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(booleanParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(booleanParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(booleanParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(booleanParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(booleanParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(booleanParameterType.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing BooleanParameterType for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(booleanParameterType.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(booleanParameterType.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in booleanParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in booleanParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(booleanParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in booleanParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in booleanParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in booleanParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in booleanParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(booleanParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(booleanParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(booleanParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(booleanParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(booleanParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(booleanParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(booleanParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(booleanParameterType.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -401,53 +368,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + return; } + + writer.WritePropertyName("revisionNumber"u8); - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteNumberValue((int)value); } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + else { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -455,249 +420,357 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "symbol": + var allowedVersionsForSymbol = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + return; } + + writer.WritePropertyName("symbol"u8); - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) + else { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("hyperLink"u8); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the BooleanParameterType"); + } + } - if(value is IEnumerable objectListHyperLink) + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not BooleanParameterType booleanParameterType) + { + throw new ArgumentException("The thing shall be a BooleanParameterType", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of BooleanParameterType since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing BooleanParameterType for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in booleanParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("category"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + foreach(var categoryItem in booleanParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(booleanParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in booleanParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in booleanParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(booleanParameterType.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteBooleanValue(booleanParameterType.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(booleanParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(booleanParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(booleanParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(booleanParameterType.Symbol); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing BooleanParameterType for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in booleanParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in booleanParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(booleanParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in booleanParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in booleanParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in booleanParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in booleanParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(booleanParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(booleanParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(booleanParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteStringValue(booleanParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(booleanParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(booleanParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(booleanParameterType.Symbol); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing BooleanParameterType for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in booleanParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in booleanParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(booleanParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in booleanParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in booleanParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in booleanParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in booleanParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(booleanParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(booleanParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(booleanParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(booleanParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(booleanParameterType.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(booleanParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(booleanParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(booleanParameterType.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing BooleanParameterType for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(booleanParameterType.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(booleanParameterType.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in booleanParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("symbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in booleanParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(booleanParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in booleanParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in booleanParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in booleanParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in booleanParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(booleanParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(booleanParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(booleanParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(booleanParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(booleanParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(booleanParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(booleanParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(booleanParameterType.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the BooleanParameterType"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/BoundsSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/BoundsSerializer.cs index a20241ef..f7d66e3c 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/BoundsSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/BoundsSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,170 +49,6 @@ namespace CDP4JsonSerializer /// public class BoundsSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Bounds bounds) - { - throw new ArgumentException("The thing shall be a Bounds", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Bounds since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Bounds for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(bounds.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in bounds.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in bounds.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("height"u8); - writer.WriteNumberValue(bounds.Height); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(bounds.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(bounds.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(bounds.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(bounds.RevisionNumber); - writer.WritePropertyName("width"u8); - writer.WriteNumberValue(bounds.Width); - writer.WritePropertyName("x"u8); - writer.WriteNumberValue(bounds.X); - writer.WritePropertyName("y"u8); - writer.WriteNumberValue(bounds.Y); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Bounds for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(bounds.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in bounds.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in bounds.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("height"u8); - writer.WriteNumberValue(bounds.Height); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(bounds.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(bounds.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(bounds.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(bounds.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(bounds.ThingPreference); - writer.WritePropertyName("width"u8); - writer.WriteNumberValue(bounds.Width); - writer.WritePropertyName("x"u8); - writer.WriteNumberValue(bounds.X); - writer.WritePropertyName("y"u8); - writer.WriteNumberValue(bounds.Y); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Bounds for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(bounds.Actor.HasValue) - { - writer.WriteStringValue(bounds.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(bounds.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in bounds.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in bounds.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("height"u8); - writer.WriteNumberValue(bounds.Height); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(bounds.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(bounds.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(bounds.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(bounds.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(bounds.ThingPreference); - writer.WritePropertyName("width"u8); - writer.WriteNumberValue(bounds.Width); - writer.WritePropertyName("x"u8); - writer.WriteNumberValue(bounds.X); - writer.WritePropertyName("y"u8); - writer.WriteNumberValue(bounds.Y); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -221,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -229,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -247,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -265,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -283,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -301,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "height": - if(!AllowedVersionsPerProperty["height"].Contains(requestedVersion)) + var allowedVersionsForHeight = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHeight.Contains(requestedVersion)) { return; } @@ -319,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -337,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -355,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -373,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -391,7 +286,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -409,7 +310,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "width": - if(!AllowedVersionsPerProperty["width"].Contains(requestedVersion)) + var allowedVersionsForWidth = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForWidth.Contains(requestedVersion)) { return; } @@ -427,7 +335,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "x": - if(!AllowedVersionsPerProperty["x"].Contains(requestedVersion)) + var allowedVersionsForX = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForX.Contains(requestedVersion)) { return; } @@ -445,7 +360,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "y": - if(!AllowedVersionsPerProperty["y"].Contains(requestedVersion)) + var allowedVersionsForY = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForY.Contains(requestedVersion)) { return; } @@ -468,24 +390,162 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "height", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "width", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "x", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "y", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not Bounds bounds) + { + throw new ArgumentException("The thing shall be a Bounds", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Bounds since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Bounds for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(bounds.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in bounds.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in bounds.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("height"u8); + writer.WriteNumberValue(bounds.Height); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(bounds.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(bounds.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(bounds.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(bounds.RevisionNumber); + writer.WritePropertyName("width"u8); + writer.WriteNumberValue(bounds.Width); + writer.WritePropertyName("x"u8); + writer.WriteNumberValue(bounds.X); + writer.WritePropertyName("y"u8); + writer.WriteNumberValue(bounds.Y); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Bounds for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(bounds.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in bounds.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in bounds.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("height"u8); + writer.WriteNumberValue(bounds.Height); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(bounds.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(bounds.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(bounds.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(bounds.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(bounds.ThingPreference); + writer.WritePropertyName("width"u8); + writer.WriteNumberValue(bounds.Width); + writer.WritePropertyName("x"u8); + writer.WriteNumberValue(bounds.X); + writer.WritePropertyName("y"u8); + writer.WriteNumberValue(bounds.Y); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Bounds for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(bounds.Actor.HasValue) + { + writer.WriteStringValue(bounds.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(bounds.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in bounds.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in bounds.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("height"u8); + writer.WriteNumberValue(bounds.Height); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(bounds.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(bounds.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(bounds.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(bounds.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(bounds.ThingPreference); + writer.WritePropertyName("width"u8); + writer.WriteNumberValue(bounds.Width); + writer.WritePropertyName("x"u8); + writer.WriteNumberValue(bounds.X); + writer.WritePropertyName("y"u8); + writer.WriteNumberValue(bounds.Y); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/BuiltInRuleVerificationSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/BuiltInRuleVerificationSerializer.cs index 9ae30150..bbcf9287 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/BuiltInRuleVerificationSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/BuiltInRuleVerificationSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,253 +49,6 @@ namespace CDP4JsonSerializer /// public class BuiltInRuleVerificationSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not BuiltInRuleVerification builtInRuleVerification) - { - throw new ArgumentException("The thing shall be a BuiltInRuleVerification", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of BuiltInRuleVerification since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing BuiltInRuleVerification for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(builtInRuleVerification.ClassKind.ToString()); - writer.WritePropertyName("executedOn"u8); - - if(builtInRuleVerification.ExecutedOn.HasValue) - { - writer.WriteStringValue(builtInRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(builtInRuleVerification.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(builtInRuleVerification.IsActive); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(builtInRuleVerification.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(builtInRuleVerification.RevisionNumber); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(builtInRuleVerification.Status.ToString()); - writer.WriteStartArray("violation"u8); - - foreach(var violationItem in builtInRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(violationItem); - } - - writer.WriteEndArray(); - - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing BuiltInRuleVerification for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(builtInRuleVerification.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in builtInRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in builtInRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("executedOn"u8); - - if(builtInRuleVerification.ExecutedOn.HasValue) - { - writer.WriteStringValue(builtInRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(builtInRuleVerification.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(builtInRuleVerification.IsActive); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(builtInRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(builtInRuleVerification.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(builtInRuleVerification.RevisionNumber); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(builtInRuleVerification.Status.ToString()); - writer.WriteStartArray("violation"u8); - - foreach(var violationItem in builtInRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(violationItem); - } - - writer.WriteEndArray(); - - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing BuiltInRuleVerification for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(builtInRuleVerification.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in builtInRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in builtInRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("executedOn"u8); - - if(builtInRuleVerification.ExecutedOn.HasValue) - { - writer.WriteStringValue(builtInRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(builtInRuleVerification.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(builtInRuleVerification.IsActive); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(builtInRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(builtInRuleVerification.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(builtInRuleVerification.RevisionNumber); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(builtInRuleVerification.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(builtInRuleVerification.ThingPreference); - writer.WriteStartArray("violation"u8); - - foreach(var violationItem in builtInRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(violationItem); - } - - writer.WriteEndArray(); - - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing BuiltInRuleVerification for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(builtInRuleVerification.Actor.HasValue) - { - writer.WriteStringValue(builtInRuleVerification.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(builtInRuleVerification.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in builtInRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in builtInRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("executedOn"u8); - - if(builtInRuleVerification.ExecutedOn.HasValue) - { - writer.WriteStringValue(builtInRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(builtInRuleVerification.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(builtInRuleVerification.IsActive); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(builtInRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(builtInRuleVerification.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(builtInRuleVerification.RevisionNumber); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(builtInRuleVerification.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(builtInRuleVerification.ThingPreference); - writer.WriteStartArray("violation"u8); - - foreach(var violationItem in builtInRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(violationItem); - } - - writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -304,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -312,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -330,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -348,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -366,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -384,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "executedon": - if(!AllowedVersionsPerProperty["executedOn"].Contains(requestedVersion)) + var allowedVersionsForExecutedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExecutedOn.Contains(requestedVersion)) { return; } @@ -402,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -420,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "isactive": - if(!AllowedVersionsPerProperty["isActive"].Contains(requestedVersion)) + var allowedVersionsForIsActive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsActive.Contains(requestedVersion)) { return; } @@ -438,7 +240,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -456,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -474,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -492,7 +317,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "status": - if(!AllowedVersionsPerProperty["status"].Contains(requestedVersion)) + var allowedVersionsForStatus = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStatus.Contains(requestedVersion)) { return; } @@ -510,7 +343,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -528,7 +367,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "violation": - if(!AllowedVersionsPerProperty["violation"].Contains(requestedVersion)) + var allowedVersionsForViolation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForViolation.Contains(requestedVersion)) { return; } @@ -551,24 +398,241 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "executedOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isActive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "status", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "violation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not BuiltInRuleVerification builtInRuleVerification) + { + throw new ArgumentException("The thing shall be a BuiltInRuleVerification", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of BuiltInRuleVerification since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing BuiltInRuleVerification for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(builtInRuleVerification.ClassKind.ToString()); + writer.WritePropertyName("executedOn"u8); + + if(builtInRuleVerification.ExecutedOn.HasValue) + { + writer.WriteStringValue(builtInRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(builtInRuleVerification.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(builtInRuleVerification.IsActive); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(builtInRuleVerification.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(builtInRuleVerification.RevisionNumber); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(builtInRuleVerification.Status.ToString()); + writer.WriteStartArray("violation"u8); + + foreach(var violationItem in builtInRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(violationItem); + } + + writer.WriteEndArray(); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing BuiltInRuleVerification for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(builtInRuleVerification.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in builtInRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in builtInRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("executedOn"u8); + + if(builtInRuleVerification.ExecutedOn.HasValue) + { + writer.WriteStringValue(builtInRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(builtInRuleVerification.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(builtInRuleVerification.IsActive); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(builtInRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(builtInRuleVerification.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(builtInRuleVerification.RevisionNumber); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(builtInRuleVerification.Status.ToString()); + writer.WriteStartArray("violation"u8); + + foreach(var violationItem in builtInRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(violationItem); + } + + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing BuiltInRuleVerification for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(builtInRuleVerification.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in builtInRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in builtInRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("executedOn"u8); + + if(builtInRuleVerification.ExecutedOn.HasValue) + { + writer.WriteStringValue(builtInRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(builtInRuleVerification.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(builtInRuleVerification.IsActive); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(builtInRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(builtInRuleVerification.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(builtInRuleVerification.RevisionNumber); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(builtInRuleVerification.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(builtInRuleVerification.ThingPreference); + writer.WriteStartArray("violation"u8); + + foreach(var violationItem in builtInRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(violationItem); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing BuiltInRuleVerification for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(builtInRuleVerification.Actor.HasValue) + { + writer.WriteStringValue(builtInRuleVerification.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(builtInRuleVerification.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in builtInRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in builtInRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("executedOn"u8); + + if(builtInRuleVerification.ExecutedOn.HasValue) + { + writer.WriteStringValue(builtInRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(builtInRuleVerification.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(builtInRuleVerification.IsActive); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(builtInRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(builtInRuleVerification.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(builtInRuleVerification.RevisionNumber); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(builtInRuleVerification.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(builtInRuleVerification.ThingPreference); + writer.WriteStartArray("violation"u8); + + foreach(var violationItem in builtInRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(violationItem); + } + + writer.WriteEndArray(); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/CategorySerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/CategorySerializer.cs index 92545d84..65054c33 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/CategorySerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/CategorySerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,385 +50,291 @@ namespace CDP4JsonSerializer public class CategorySerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not Category category) - { - throw new ArgumentException("The thing shall be a Category", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Category since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Category for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in category.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(category.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in category.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in category.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(category.Iid); - writer.WritePropertyName("isAbstract"u8); - writer.WriteBooleanValue(category.IsAbstract); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(category.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(category.Name); - writer.WriteStartArray("permissibleClass"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var permissibleClassItem in category.PermissibleClass) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(permissibleClassItem.ToString()); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(category.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(category.ShortName); - writer.WriteStartArray("superCategory"u8); + writer.WriteStartArray("alias"u8); - foreach(var superCategoryItem in category.SuperCategory.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(superCategoryItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Category for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in category.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(category.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in category.Definition.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in category.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in category.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in category.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(category.Iid); - writer.WritePropertyName("isAbstract"u8); - writer.WriteBooleanValue(category.IsAbstract); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(category.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(category.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(category.Name); - writer.WriteStartArray("permissibleClass"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var permissibleClassItem in category.PermissibleClass) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(permissibleClassItem.ToString()); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(category.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(category.ShortName); - writer.WriteStartArray("superCategory"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var superCategoryItem in category.SuperCategory.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(superCategoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Category for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in category.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(category.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var definitionItem in category.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(definitionItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in category.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var excludedPersonItem in category.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(excludedPersonItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in category.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(category.Iid); - writer.WritePropertyName("isAbstract"u8); - writer.WriteBooleanValue(category.IsAbstract); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(category.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(category.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(category.Name); - writer.WriteStartArray("permissibleClass"u8); - - foreach(var permissibleClassItem in category.PermissibleClass) + + if(value != null) { - writer.WriteStringValue(permissibleClassItem.ToString()); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(category.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(category.ShortName); - writer.WriteStartArray("superCategory"u8); + break; + case "isabstract": + var allowedVersionsForIsAbstract = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var superCategoryItem in category.SuperCategory.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsAbstract.Contains(requestedVersion)) { - writer.WriteStringValue(superCategoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isAbstract"u8); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(category.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Category for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(category.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(category.Actor.Value); + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in category.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(category.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in category.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in category.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in category.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in category.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(category.Iid); - writer.WritePropertyName("isAbstract"u8); - writer.WriteBooleanValue(category.IsAbstract); writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(category.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(category.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(category.Name); - writer.WriteStartArray("permissibleClass"u8); - - foreach(var permissibleClassItem in category.PermissibleClass) + + if(value != null) { - writer.WriteStringValue(permissibleClassItem.ToString()); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(category.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(category.ShortName); - writer.WriteStartArray("superCategory"u8); - - foreach(var superCategoryItem in category.SuperCategory.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(superCategoryItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(category.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -437,35 +342,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -473,89 +368,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + case "permissibleclass": + var allowedVersionsForPermissibleClass = new List { - return; - } - - writer.WriteStartArray("excludedDomain"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(!allowedVersionsForPermissibleClass.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("permissibleClass"u8); - if(value is IEnumerable objectListExcludedPerson) + if(value is IEnumerable objectListPermissibleClass) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var permissibleClassItem in objectListPermissibleClass) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((ClassKind)permissibleClassItem).ToString()); } } writer.WriteEndArray(); break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } - - writer.WriteStartArray("hyperLink"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -563,35 +420,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isabstract": - if(!AllowedVersionsPerProperty["isAbstract"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("isAbstract"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else + case "shortname": + var allowedVersionsForShortName = new List { - writer.WriteNullValue(); - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isDeprecated"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -599,31 +446,45 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "supercategory": + var allowedVersionsForSuperCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSuperCategory.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteStartArray("superCategory"u8); + + if(value is IEnumerable objectListSuperCategory) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + foreach(var superCategoryItem in objectListSuperCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(superCategoryItem); + } } - else + + writer.WriteEndArray(); + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List { - writer.WriteNullValue(); - } + "1.2.0", + "1.3.0", + }; - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("name"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { @@ -635,124 +496,339 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "permissibleclass": - if(!AllowedVersionsPerProperty["permissibleClass"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("permissibleClass"u8); + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the Category"); + } + } - if(value is IEnumerable objectListPermissibleClass) + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not Category category) + { + throw new ArgumentException("The thing shall be a Category", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Category since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Category for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in category.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var permissibleClassItem in objectListPermissibleClass) - { - writer.WriteStringValue(((ClassKind)permissibleClassItem).ToString()); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(category.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in category.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in category.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(category.Iid); + writer.WritePropertyName("isAbstract"u8); + writer.WriteBooleanValue(category.IsAbstract); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(category.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(category.Name); + writer.WriteStartArray("permissibleClass"u8); + + foreach(var permissibleClassItem in category.PermissibleClass) { - writer.WriteNullValue(); + writer.WriteStringValue(permissibleClassItem.ToString()); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(category.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(category.ShortName); + writer.WriteStartArray("superCategory"u8); + + foreach(var superCategoryItem in category.SuperCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(superCategoryItem); + } + + writer.WriteEndArray(); break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Category for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in category.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(category.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in category.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in category.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "supercategory": - if(!AllowedVersionsPerProperty["superCategory"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in category.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in category.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(category.Iid); + writer.WritePropertyName("isAbstract"u8); + writer.WriteBooleanValue(category.IsAbstract); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(category.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(category.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(category.Name); + writer.WriteStartArray("permissibleClass"u8); + + foreach(var permissibleClassItem in category.PermissibleClass) + { + writer.WriteStringValue(permissibleClassItem.ToString()); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(category.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(category.ShortName); writer.WriteStartArray("superCategory"u8); - if(value is IEnumerable objectListSuperCategory) + foreach(var superCategoryItem in category.SuperCategory.OrderBy(x => x, this.GuidComparer)) { - foreach(var superCategoryItem in objectListSuperCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(superCategoryItem); - } + writer.WriteStringValue(superCategoryItem); } - + writer.WriteEndArray(); break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Category for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in category.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(category.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in category.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in category.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in category.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in category.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(category.Iid); + writer.WritePropertyName("isAbstract"u8); + writer.WriteBooleanValue(category.IsAbstract); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(category.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(category.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(category.Name); + writer.WriteStartArray("permissibleClass"u8); + + foreach(var permissibleClassItem in category.PermissibleClass) + { + writer.WriteStringValue(permissibleClassItem.ToString()); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(category.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(category.ShortName); + writer.WriteStartArray("superCategory"u8); + + foreach(var superCategoryItem in category.SuperCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(superCategoryItem); + } + + writer.WriteEndArray(); writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteStringValue(category.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Category for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(category.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(category.Actor.Value); } else { writer.WriteNullValue(); } + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in category.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(category.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in category.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in category.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in category.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in category.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(category.Iid); + writer.WritePropertyName("isAbstract"u8); + writer.WriteBooleanValue(category.IsAbstract); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(category.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(category.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(category.Name); + writer.WriteStartArray("permissibleClass"u8); + + foreach(var permissibleClassItem in category.PermissibleClass) + { + writer.WriteStringValue(permissibleClassItem.ToString()); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(category.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(category.ShortName); + writer.WriteStartArray("superCategory"u8); + + foreach(var superCategoryItem in category.SuperCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(superCategoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(category.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the Category"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isAbstract", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "permissibleClass", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "superCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ChangeProposalSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ChangeProposalSerializer.cs index f51c6366..eaa2878c 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ChangeProposalSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ChangeProposalSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,460 +50,330 @@ namespace CDP4JsonSerializer public class ChangeProposalSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ChangeProposal changeProposal) - { - throw new ArgumentException("The thing shall be a ChangeProposal", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ChangeProposal since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ChangeProposal for Version 1.1.0"); - writer.WriteStartArray("approvedBy"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var approvedByItem in changeProposal.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(changeProposal.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in changeProposal.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("changeRequest"u8); - writer.WriteStringValue(changeProposal.ChangeRequest); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(changeProposal.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(changeProposal.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(changeProposal.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(changeProposal.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "approvedby": + var allowedVersionsForApprovedBy = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in changeProposal.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForApprovedBy.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("approvedBy"u8); - foreach(var excludedDomainItem in changeProposal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListApprovedBy) { - writer.WriteStringValue(excludedDomainItem); + foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(approvedByItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "author": + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in changeProposal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("author"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(changeProposal.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(changeProposal.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(changeProposal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(changeProposal.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(changeProposal.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(changeProposal.PrimaryAnnotatedThing.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var relatedThingItem in changeProposal.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(relatedThingItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(changeProposal.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(changeProposal.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + writer.WriteStartArray("category"u8); - foreach(var sourceAnnotationItem in changeProposal.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(sourceAnnotationItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(changeProposal.Status.ToString()); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(changeProposal.Title); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ChangeProposal for Version 1.2.0"); - writer.WriteStartArray("approvedBy"u8); + case "changerequest": + var allowedVersionsForChangeRequest = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in changeProposal.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForChangeRequest.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("changeRequest"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(changeProposal.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in changeProposal.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("changeRequest"u8); - writer.WriteStringValue(changeProposal.ChangeRequest); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(changeProposal.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(changeProposal.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(changeProposal.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(changeProposal.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "classification": + var allowedVersionsForClassification = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in changeProposal.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassification.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in changeProposal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in changeProposal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(changeProposal.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(changeProposal.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(changeProposal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(changeProposal.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(changeProposal.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(changeProposal.PrimaryAnnotatedThing.Value); + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in changeProposal.RelatedThing.OrderBy(x => x, this.GuidComparer)) + break; + case "content": + var allowedVersionsForContent = new List { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(changeProposal.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(changeProposal.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var sourceAnnotationItem in changeProposal.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContent.Contains(requestedVersion)) { - writer.WriteStringValue(sourceAnnotationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("content"u8); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(changeProposal.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(changeProposal.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(changeProposal.Title); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ChangeProposal for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(changeProposal.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(changeProposal.Actor.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("approvedBy"u8); + break; + case "createdon": + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in changeProposal.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("createdOn"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(changeProposal.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in changeProposal.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("changeRequest"u8); - writer.WriteStringValue(changeProposal.ChangeRequest); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(changeProposal.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(changeProposal.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(changeProposal.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(changeProposal.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in changeProposal.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in changeProposal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in changeProposal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(changeProposal.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(changeProposal.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(changeProposal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(changeProposal.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(changeProposal.PrimaryAnnotatedThing.HasValue) - { - writer.WriteStringValue(changeProposal.PrimaryAnnotatedThing.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in changeProposal.RelatedThing.OrderBy(x => x, this.GuidComparer)) + break; + case "discussion": + var allowedVersionsForDiscussion = new List { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(changeProposal.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(changeProposal.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var sourceAnnotationItem in changeProposal.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDiscussion.Contains(requestedVersion)) { - writer.WriteStringValue(sourceAnnotationItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("status"u8); - writer.WriteStringValue(changeProposal.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(changeProposal.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(changeProposal.Title); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + writer.WriteStartArray("discussion"u8); - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(value is IEnumerable objectListDiscussion) { - return; + foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } } - - writer.WritePropertyName("actor"u8); - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteNullValue(); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - break; - case "approvedby": - if(!AllowedVersionsPerProperty["approvedBy"].Contains(requestedVersion)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } - writer.WriteStartArray("approvedBy"u8); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListApprovedBy) + if(value is IEnumerable objectListExcludedDomain) { - foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(approvedByItem); + writer.WriteStringValue(excludedDomainItem); } } writer.WriteEndArray(); break; - case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("author"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + case "excludedperson": + var allowedVersionsForExcludedPerson = new List { - writer.WriteNullValue(); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListExcludedPerson) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(excludedPersonItem); } } writer.WriteEndArray(); break; - case "changerequest": - if(!AllowedVersionsPerProperty["changeRequest"].Contains(requestedVersion)) + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } - writer.WritePropertyName("changeRequest"u8); + writer.WritePropertyName("iid"u8); if(value != null) { @@ -516,17 +385,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "classification": - if(!AllowedVersionsPerProperty["classification"].Contains(requestedVersion)) + case "languagecode": + var allowedVersionsForLanguageCode = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classification"u8); + writer.WritePropertyName("languageCode"u8); if(value != null) { - writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -534,17 +410,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -552,17 +435,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + case "owner": + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } - writer.WritePropertyName("content"u8); + writer.WritePropertyName("owner"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue((Guid)value); } else { @@ -570,17 +460,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + case "primaryannotatedthing": + var allowedVersionsForPrimaryAnnotatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPrimaryAnnotatedThing.Contains(requestedVersion)) { return; } - writer.WritePropertyName("createdOn"u8); + writer.WritePropertyName("primaryAnnotatedThing"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((Guid)value); } else { @@ -588,71 +485,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "discussion": - if(!AllowedVersionsPerProperty["discussion"].Contains(requestedVersion)) + case "relatedthing": + var allowedVersionsForRelatedThing = new List { - return; - } - - writer.WriteStartArray("discussion"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDiscussion) - { - foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForRelatedThing.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("relatedThing"u8); - if(value is IEnumerable objectListExcludedDomain) + if(value is IEnumerable objectListRelatedThing) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(relatedThingItem); } } writer.WriteEndArray(); break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -660,13 +535,20 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("languageCode"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { @@ -678,17 +560,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "sourceannotation": + var allowedVersionsForSourceAnnotation = new List { - return; - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + if(!allowedVersionsForSourceAnnotation.Contains(requestedVersion)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + return; + } + + writer.WriteStartArray("sourceAnnotation"u8); + + if(value is IEnumerable objectListSourceAnnotation) + { + foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); + } + } + + writer.WriteEndArray(); + break; + case "status": + var allowedVersionsForStatus = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStatus.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("status"u8); + + if(value != null) + { + writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); } else { @@ -696,17 +610,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("owner"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -714,17 +634,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "primaryannotatedthing": - if(!AllowedVersionsPerProperty["primaryAnnotatedThing"].Contains(requestedVersion)) + case "title": + var allowedVersionsForTitle = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTitle.Contains(requestedVersion)) { return; } - writer.WritePropertyName("primaryAnnotatedThing"u8); + writer.WritePropertyName("title"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -732,167 +659,351 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "relatedthing": - if(!AllowedVersionsPerProperty["relatedThing"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ChangeProposal"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ChangeProposal changeProposal) + { + throw new ArgumentException("The thing shall be a ChangeProposal", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ChangeProposal since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ChangeProposal for Version 1.1.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in changeProposal.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WriteStartArray("relatedThing"u8); + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(changeProposal.Author); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListRelatedThing) + foreach(var categoryItem in changeProposal.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WritePropertyName("changeRequest"u8); + writer.WriteStringValue(changeProposal.ChangeRequest); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(changeProposal.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(changeProposal.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(changeProposal.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(changeProposal.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in changeProposal.Discussion.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(discussionItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in changeProposal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in changeProposal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(changeProposal.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(changeProposal.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(changeProposal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(changeProposal.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(changeProposal.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(changeProposal.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in changeProposal.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(changeProposal.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(changeProposal.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in changeProposal.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(sourceAnnotationItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(changeProposal.Status.ToString()); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(changeProposal.Title); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ChangeProposal for Version 1.2.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in changeProposal.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(approvedByItem); } - break; - case "sourceannotation": - if(!AllowedVersionsPerProperty["sourceAnnotation"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(changeProposal.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in changeProposal.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WriteStartArray("sourceAnnotation"u8); + writer.WriteEndArray(); + writer.WritePropertyName("changeRequest"u8); + writer.WriteStringValue(changeProposal.ChangeRequest); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(changeProposal.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(changeProposal.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(changeProposal.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(changeProposal.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); - if(value is IEnumerable objectListSourceAnnotation) + foreach(var discussionItem in changeProposal.Discussion.OrderBy(x => x, this.GuidComparer)) { - foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sourceAnnotationItem); - } + writer.WriteStringValue(discussionItem); } - + writer.WriteEndArray(); - break; - case "status": - if(!AllowedVersionsPerProperty["status"].Contains(requestedVersion)) + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in changeProposal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("status"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in changeProposal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(changeProposal.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(changeProposal.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(changeProposal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(changeProposal.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(changeProposal.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(changeProposal.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in changeProposal.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(changeProposal.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(changeProposal.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in changeProposal.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); } + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(changeProposal.Status.ToString()); writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteStringValue(changeProposal.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(changeProposal.Title); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ChangeProposal for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(changeProposal.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(changeProposal.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "title": - if(!AllowedVersionsPerProperty["title"].Contains(requestedVersion)) + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in changeProposal.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("title"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(changeProposal.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in changeProposal.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("changeRequest"u8); + writer.WriteStringValue(changeProposal.ChangeRequest); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(changeProposal.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(changeProposal.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(changeProposal.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(changeProposal.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in changeProposal.Discussion.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in changeProposal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in changeProposal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(changeProposal.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(changeProposal.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(changeProposal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(changeProposal.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(changeProposal.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(changeProposal.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in changeProposal.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(changeProposal.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(changeProposal.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in changeProposal.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(changeProposal.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(changeProposal.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(changeProposal.Title); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ChangeProposal"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "approvedBy", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "changeRequest", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classification", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "discussion", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "primaryAnnotatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "relatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "sourceAnnotation", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "status", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "title", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ChangeRequestSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ChangeRequestSerializer.cs index a7b2b58e..2a227e46 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ChangeRequestSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ChangeRequestSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,418 +50,305 @@ namespace CDP4JsonSerializer public class ChangeRequestSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ChangeRequest changeRequest) - { - throw new ArgumentException("The thing shall be a ChangeRequest", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ChangeRequest since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ChangeRequest for Version 1.1.0"); - writer.WriteStartArray("approvedBy"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var approvedByItem in changeRequest.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(changeRequest.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in changeRequest.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(changeRequest.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(changeRequest.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(changeRequest.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(changeRequest.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "approvedby": + var allowedVersionsForApprovedBy = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in changeRequest.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForApprovedBy.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("approvedBy"u8); - foreach(var excludedDomainItem in changeRequest.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListApprovedBy) { - writer.WriteStringValue(excludedDomainItem); + foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(approvedByItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "author": + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in changeRequest.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("author"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(changeRequest.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(changeRequest.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(changeRequest.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(changeRequest.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(changeRequest.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(changeRequest.PrimaryAnnotatedThing.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var relatedThingItem in changeRequest.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(relatedThingItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(changeRequest.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(changeRequest.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + writer.WriteStartArray("category"u8); - foreach(var sourceAnnotationItem in changeRequest.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(sourceAnnotationItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(changeRequest.Status.ToString()); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(changeRequest.Title); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ChangeRequest for Version 1.2.0"); - writer.WriteStartArray("approvedBy"u8); + case "classification": + var allowedVersionsForClassification = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in changeRequest.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassification.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(changeRequest.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in changeRequest.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(changeRequest.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(changeRequest.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(changeRequest.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(changeRequest.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in changeRequest.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in changeRequest.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "content": + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in changeRequest.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContent.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("content"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(changeRequest.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(changeRequest.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(changeRequest.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(changeRequest.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(changeRequest.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(changeRequest.PrimaryAnnotatedThing.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in changeRequest.RelatedThing.OrderBy(x => x, this.GuidComparer)) + break; + case "createdon": + var allowedVersionsForCreatedOn = new List { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(changeRequest.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(changeRequest.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var sourceAnnotationItem in changeRequest.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { - writer.WriteStringValue(sourceAnnotationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("createdOn"u8); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(changeRequest.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(changeRequest.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(changeRequest.Title); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ChangeRequest for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(changeRequest.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(changeRequest.Actor.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("approvedBy"u8); + break; + case "discussion": + var allowedVersionsForDiscussion = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in changeRequest.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDiscussion.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(changeRequest.Author); - writer.WriteStartArray("category"u8); + writer.WriteStartArray("discussion"u8); - foreach(var categoryItem in changeRequest.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDiscussion) { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(changeRequest.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(changeRequest.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(changeRequest.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(changeRequest.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in changeRequest.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); + foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in changeRequest.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in changeRequest.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(changeRequest.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(changeRequest.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(changeRequest.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(changeRequest.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(changeRequest.PrimaryAnnotatedThing.HasValue) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(changeRequest.PrimaryAnnotatedThing.Value); - } - else - { - writer.WriteNullValue(); + return; } - writer.WriteStartArray("relatedThing"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var relatedThingItem in changeRequest.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(relatedThingItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(changeRequest.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(changeRequest.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); - - foreach(var sourceAnnotationItem in changeRequest.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sourceAnnotationItem); - } - writer.WriteEndArray(); - - writer.WritePropertyName("status"u8); - writer.WriteStringValue(changeRequest.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(changeRequest.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(changeRequest.Title); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + case "excludedperson": + var allowedVersionsForExcludedPerson = new List { - writer.WriteNullValue(); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - break; - case "approvedby": - if(!AllowedVersionsPerProperty["approvedBy"].Contains(requestedVersion)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } - writer.WriteStartArray("approvedBy"u8); + writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListApprovedBy) + if(value is IEnumerable objectListExcludedPerson) { - foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(approvedByItem); + writer.WriteStringValue(excludedPersonItem); } } writer.WriteEndArray(); break; - case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } - writer.WritePropertyName("author"u8); + writer.WritePropertyName("iid"u8); if(value != null) { @@ -474,35 +360,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "languagecode": + var allowedVersionsForLanguageCode = new List { - return; - } - - writer.WriteStartArray("category"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListCategory) - { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - } - - writer.WriteEndArray(); - break; - case "classification": - if(!AllowedVersionsPerProperty["classification"].Contains(requestedVersion)) + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classification"u8); + writer.WritePropertyName("languageCode"u8); if(value != null) { - writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -510,17 +385,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -528,17 +410,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + case "owner": + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } - writer.WritePropertyName("content"u8); + writer.WritePropertyName("owner"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue((Guid)value); } else { @@ -546,17 +435,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + case "primaryannotatedthing": + var allowedVersionsForPrimaryAnnotatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPrimaryAnnotatedThing.Contains(requestedVersion)) { return; } - writer.WritePropertyName("createdOn"u8); + writer.WritePropertyName("primaryAnnotatedThing"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((Guid)value); } else { @@ -564,71 +460,124 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "discussion": - if(!AllowedVersionsPerProperty["discussion"].Contains(requestedVersion)) + case "relatedthing": + var allowedVersionsForRelatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRelatedThing.Contains(requestedVersion)) { return; } - writer.WriteStartArray("discussion"u8); + writer.WriteStartArray("relatedThing"u8); - if(value is IEnumerable objectListDiscussion) + if(value is IEnumerable objectListRelatedThing) { - foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(discussionItem); + writer.WriteStringValue(relatedThingItem); } } writer.WriteEndArray(); break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } - if(value is IEnumerable objectListExcludedDomain) + break; + case "shortname": + var allowedVersionsForShortName = new List { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; } + + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "sourceannotation": + var allowedVersionsForSourceAnnotation = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSourceAnnotation.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("sourceAnnotation"u8); - if(value is IEnumerable objectListExcludedPerson) + if(value is IEnumerable objectListSourceAnnotation) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(sourceAnnotationItem); } } writer.WriteEndArray(); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + case "status": + var allowedVersionsForStatus = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStatus.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("status"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); } else { @@ -636,13 +585,19 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("languageCode"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { @@ -654,17 +609,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "title": + var allowedVersionsForTitle = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTitle.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); + writer.WritePropertyName("title"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((string)value); } else { @@ -672,202 +634,345 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ChangeRequest"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ChangeRequest changeRequest) + { + throw new ArgumentException("The thing shall be a ChangeRequest", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ChangeRequest since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ChangeRequest for Version 1.1.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in changeRequest.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("owner"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(changeRequest.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in changeRequest.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(changeRequest.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(changeRequest.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(changeRequest.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(changeRequest.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in changeRequest.Discussion.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(discussionItem); } - break; - case "primaryannotatedthing": - if(!AllowedVersionsPerProperty["primaryAnnotatedThing"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in changeRequest.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in changeRequest.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(changeRequest.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(changeRequest.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(changeRequest.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(changeRequest.Owner); writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(value != null) + + if(changeRequest.PrimaryAnnotatedThing.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(changeRequest.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "relatedthing": - if(!AllowedVersionsPerProperty["relatedThing"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in changeRequest.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); } - writer.WriteStartArray("relatedThing"u8); + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(changeRequest.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(changeRequest.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); - if(value is IEnumerable objectListRelatedThing) + foreach(var sourceAnnotationItem in changeRequest.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } + writer.WriteStringValue(sourceAnnotationItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(changeRequest.Status.ToString()); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(changeRequest.Title); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ChangeRequest for Version 1.2.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in changeRequest.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(changeRequest.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in changeRequest.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(changeRequest.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(changeRequest.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(changeRequest.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(changeRequest.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in changeRequest.Discussion.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(discussionItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in changeRequest.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in changeRequest.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(changeRequest.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(changeRequest.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(changeRequest.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(changeRequest.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(changeRequest.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(changeRequest.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "sourceannotation": - if(!AllowedVersionsPerProperty["sourceAnnotation"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in changeRequest.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(changeRequest.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(changeRequest.ShortName); writer.WriteStartArray("sourceAnnotation"u8); - if(value is IEnumerable objectListSourceAnnotation) + foreach(var sourceAnnotationItem in changeRequest.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sourceAnnotationItem); - } + writer.WriteStringValue(sourceAnnotationItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(changeRequest.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(changeRequest.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(changeRequest.Title); break; - case "status": - if(!AllowedVersionsPerProperty["status"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ChangeRequest for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("status"u8); - - if(value != null) + if(changeRequest.Actor.HasValue) { - writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); + writer.WriteStringValue(changeRequest.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in changeRequest.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(changeRequest.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in changeRequest.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(changeRequest.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(changeRequest.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(changeRequest.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(changeRequest.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in changeRequest.Discussion.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(discussionItem); } - break; - case "title": - if(!AllowedVersionsPerProperty["title"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in changeRequest.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("title"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in changeRequest.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(changeRequest.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(changeRequest.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(changeRequest.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(changeRequest.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(changeRequest.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(changeRequest.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in changeRequest.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(changeRequest.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(changeRequest.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in changeRequest.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(changeRequest.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(changeRequest.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(changeRequest.Title); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ChangeRequest"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "approvedBy", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classification", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "discussion", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "primaryAnnotatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "relatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "sourceAnnotation", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "status", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "title", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/CitationSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/CitationSerializer.cs index 423ff51c..51f47dc8 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/CitationSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/CitationSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,189 +49,6 @@ namespace CDP4JsonSerializer /// public class CitationSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Citation citation) - { - throw new ArgumentException("The thing shall be a Citation", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Citation since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Citation for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(citation.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(citation.Iid); - writer.WritePropertyName("isAdaptation"u8); - writer.WriteBooleanValue(citation.IsAdaptation); - writer.WritePropertyName("location"u8); - writer.WriteStringValue(citation.Location); - writer.WritePropertyName("remark"u8); - writer.WriteStringValue(citation.Remark); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(citation.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(citation.ShortName); - writer.WritePropertyName("source"u8); - writer.WriteStringValue(citation.Source); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Citation for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(citation.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in citation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in citation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(citation.Iid); - writer.WritePropertyName("isAdaptation"u8); - writer.WriteBooleanValue(citation.IsAdaptation); - writer.WritePropertyName("location"u8); - writer.WriteStringValue(citation.Location); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(citation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("remark"u8); - writer.WriteStringValue(citation.Remark); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(citation.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(citation.ShortName); - writer.WritePropertyName("source"u8); - writer.WriteStringValue(citation.Source); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Citation for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(citation.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in citation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in citation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(citation.Iid); - writer.WritePropertyName("isAdaptation"u8); - writer.WriteBooleanValue(citation.IsAdaptation); - writer.WritePropertyName("location"u8); - writer.WriteStringValue(citation.Location); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(citation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("remark"u8); - writer.WriteStringValue(citation.Remark); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(citation.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(citation.ShortName); - writer.WritePropertyName("source"u8); - writer.WriteStringValue(citation.Source); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(citation.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Citation for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(citation.Actor.HasValue) - { - writer.WriteStringValue(citation.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(citation.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in citation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in citation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(citation.Iid); - writer.WritePropertyName("isAdaptation"u8); - writer.WriteBooleanValue(citation.IsAdaptation); - writer.WritePropertyName("location"u8); - writer.WriteStringValue(citation.Location); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(citation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("remark"u8); - writer.WriteStringValue(citation.Remark); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(citation.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(citation.ShortName); - writer.WritePropertyName("source"u8); - writer.WriteStringValue(citation.Source); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(citation.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -240,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -248,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -266,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -284,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -302,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -320,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -338,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "isadaptation": - if(!AllowedVersionsPerProperty["isAdaptation"].Contains(requestedVersion)) + var allowedVersionsForIsAdaptation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsAdaptation.Contains(requestedVersion)) { return; } @@ -356,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "location": - if(!AllowedVersionsPerProperty["location"].Contains(requestedVersion)) + var allowedVersionsForLocation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLocation.Contains(requestedVersion)) { return; } @@ -374,7 +240,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -392,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "remark": - if(!AllowedVersionsPerProperty["remark"].Contains(requestedVersion)) + var allowedVersionsForRemark = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRemark.Contains(requestedVersion)) { return; } @@ -410,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -428,7 +317,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -446,7 +343,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "source": - if(!AllowedVersionsPerProperty["source"].Contains(requestedVersion)) + var allowedVersionsForSource = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSource.Contains(requestedVersion)) { return; } @@ -464,7 +369,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -487,24 +398,181 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isAdaptation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "location", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "remark", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "source", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Citation citation) + { + throw new ArgumentException("The thing shall be a Citation", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Citation since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Citation for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(citation.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(citation.Iid); + writer.WritePropertyName("isAdaptation"u8); + writer.WriteBooleanValue(citation.IsAdaptation); + writer.WritePropertyName("location"u8); + writer.WriteStringValue(citation.Location); + writer.WritePropertyName("remark"u8); + writer.WriteStringValue(citation.Remark); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(citation.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(citation.ShortName); + writer.WritePropertyName("source"u8); + writer.WriteStringValue(citation.Source); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Citation for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(citation.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in citation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in citation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(citation.Iid); + writer.WritePropertyName("isAdaptation"u8); + writer.WriteBooleanValue(citation.IsAdaptation); + writer.WritePropertyName("location"u8); + writer.WriteStringValue(citation.Location); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(citation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("remark"u8); + writer.WriteStringValue(citation.Remark); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(citation.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(citation.ShortName); + writer.WritePropertyName("source"u8); + writer.WriteStringValue(citation.Source); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Citation for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(citation.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in citation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in citation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(citation.Iid); + writer.WritePropertyName("isAdaptation"u8); + writer.WriteBooleanValue(citation.IsAdaptation); + writer.WritePropertyName("location"u8); + writer.WriteStringValue(citation.Location); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(citation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("remark"u8); + writer.WriteStringValue(citation.Remark); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(citation.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(citation.ShortName); + writer.WritePropertyName("source"u8); + writer.WriteStringValue(citation.Source); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(citation.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Citation for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(citation.Actor.HasValue) + { + writer.WriteStringValue(citation.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(citation.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in citation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in citation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(citation.Iid); + writer.WritePropertyName("isAdaptation"u8); + writer.WriteBooleanValue(citation.IsAdaptation); + writer.WritePropertyName("location"u8); + writer.WriteStringValue(citation.Location); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(citation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("remark"u8); + writer.WriteStringValue(citation.Remark); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(citation.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(citation.ShortName); + writer.WritePropertyName("source"u8); + writer.WriteStringValue(citation.Source); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(citation.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ColorSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ColorSerializer.cs index 24f898ef..6d9c521f 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ColorSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ColorSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,181 +49,6 @@ namespace CDP4JsonSerializer /// public class ColorSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Color color) - { - throw new ArgumentException("The thing shall be a Color", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Color since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Color for Version 1.0.0"); - writer.WritePropertyName("blue"u8); - writer.WriteNumberValue(color.Blue); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(color.ClassKind.ToString()); - writer.WritePropertyName("green"u8); - writer.WriteNumberValue(color.Green); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(color.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(color.Name); - writer.WritePropertyName("red"u8); - writer.WriteNumberValue(color.Red); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(color.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Color for Version 1.1.0"); - writer.WritePropertyName("blue"u8); - writer.WriteNumberValue(color.Blue); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(color.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in color.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in color.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("green"u8); - writer.WriteNumberValue(color.Green); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(color.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(color.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(color.Name); - writer.WritePropertyName("red"u8); - writer.WriteNumberValue(color.Red); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(color.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Color for Version 1.2.0"); - writer.WritePropertyName("blue"u8); - writer.WriteNumberValue(color.Blue); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(color.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in color.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in color.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("green"u8); - writer.WriteNumberValue(color.Green); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(color.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(color.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(color.Name); - writer.WritePropertyName("red"u8); - writer.WriteNumberValue(color.Red); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(color.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(color.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Color for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(color.Actor.HasValue) - { - writer.WriteStringValue(color.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("blue"u8); - writer.WriteNumberValue(color.Blue); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(color.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in color.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in color.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("green"u8); - writer.WriteNumberValue(color.Green); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(color.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(color.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(color.Name); - writer.WritePropertyName("red"u8); - writer.WriteNumberValue(color.Red); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(color.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(color.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -232,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -240,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -258,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "blue": - if(!AllowedVersionsPerProperty["blue"].Contains(requestedVersion)) + var allowedVersionsForBlue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForBlue.Contains(requestedVersion)) { return; } @@ -276,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -294,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -312,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -330,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "green": - if(!AllowedVersionsPerProperty["green"].Contains(requestedVersion)) + var allowedVersionsForGreen = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForGreen.Contains(requestedVersion)) { return; } @@ -348,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -366,7 +240,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -384,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -402,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "red": - if(!AllowedVersionsPerProperty["red"].Contains(requestedVersion)) + var allowedVersionsForRed = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRed.Contains(requestedVersion)) { return; } @@ -420,7 +317,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -438,7 +343,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -461,23 +372,173 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "blue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "green", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "red", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Color color) + { + throw new ArgumentException("The thing shall be a Color", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Color since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Color for Version 1.0.0"); + writer.WritePropertyName("blue"u8); + writer.WriteNumberValue(color.Blue); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(color.ClassKind.ToString()); + writer.WritePropertyName("green"u8); + writer.WriteNumberValue(color.Green); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(color.Iid); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(color.Name); + writer.WritePropertyName("red"u8); + writer.WriteNumberValue(color.Red); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(color.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Color for Version 1.1.0"); + writer.WritePropertyName("blue"u8); + writer.WriteNumberValue(color.Blue); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(color.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in color.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in color.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("green"u8); + writer.WriteNumberValue(color.Green); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(color.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(color.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(color.Name); + writer.WritePropertyName("red"u8); + writer.WriteNumberValue(color.Red); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(color.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Color for Version 1.2.0"); + writer.WritePropertyName("blue"u8); + writer.WriteNumberValue(color.Blue); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(color.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in color.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in color.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("green"u8); + writer.WriteNumberValue(color.Green); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(color.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(color.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(color.Name); + writer.WritePropertyName("red"u8); + writer.WriteNumberValue(color.Red); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(color.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(color.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Color for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(color.Actor.HasValue) + { + writer.WriteStringValue(color.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("blue"u8); + writer.WriteNumberValue(color.Blue); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(color.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in color.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in color.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("green"u8); + writer.WriteNumberValue(color.Green); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(color.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(color.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(color.Name); + writer.WritePropertyName("red"u8); + writer.WriteNumberValue(color.Red); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(color.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(color.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/CommonFileStoreSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/CommonFileStoreSerializer.cs index f246db2b..a5f4403a 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/CommonFileStoreSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/CommonFileStoreSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,245 +49,6 @@ namespace CDP4JsonSerializer /// public class CommonFileStoreSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not CommonFileStore commonFileStore) - { - throw new ArgumentException("The thing shall be a CommonFileStore", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of CommonFileStore since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing CommonFileStore for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(commonFileStore.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(commonFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("file"u8); - - foreach(var fileItem in commonFileStore.File.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(fileItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("folder"u8); - - foreach(var folderItem in commonFileStore.Folder.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(folderItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(commonFileStore.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(commonFileStore.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(commonFileStore.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(commonFileStore.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing CommonFileStore for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(commonFileStore.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(commonFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in commonFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in commonFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("file"u8); - - foreach(var fileItem in commonFileStore.File.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(fileItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("folder"u8); - - foreach(var folderItem in commonFileStore.Folder.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(folderItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(commonFileStore.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(commonFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(commonFileStore.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(commonFileStore.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(commonFileStore.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing CommonFileStore for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(commonFileStore.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(commonFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in commonFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in commonFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("file"u8); - - foreach(var fileItem in commonFileStore.File.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(fileItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("folder"u8); - - foreach(var folderItem in commonFileStore.Folder.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(folderItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(commonFileStore.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(commonFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(commonFileStore.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(commonFileStore.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(commonFileStore.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(commonFileStore.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing CommonFileStore for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(commonFileStore.Actor.HasValue) - { - writer.WriteStringValue(commonFileStore.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(commonFileStore.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(commonFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in commonFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in commonFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("file"u8); - - foreach(var fileItem in commonFileStore.File.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(fileItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("folder"u8); - - foreach(var folderItem in commonFileStore.Folder.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(folderItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(commonFileStore.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(commonFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(commonFileStore.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(commonFileStore.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(commonFileStore.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(commonFileStore.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -296,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -304,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -322,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -340,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -358,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -376,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -394,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "file": - if(!AllowedVersionsPerProperty["file"].Contains(requestedVersion)) + var allowedVersionsForFile = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFile.Contains(requestedVersion)) { return; } @@ -412,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "folder": - if(!AllowedVersionsPerProperty["folder"].Contains(requestedVersion)) + var allowedVersionsForFolder = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFolder.Contains(requestedVersion)) { return; } @@ -430,7 +240,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -448,7 +266,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -466,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -484,7 +317,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -502,7 +343,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -520,7 +369,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -543,24 +398,229 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "file", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "folder", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not CommonFileStore commonFileStore) + { + throw new ArgumentException("The thing shall be a CommonFileStore", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of CommonFileStore since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing CommonFileStore for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(commonFileStore.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(commonFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("file"u8); + + foreach(var fileItem in commonFileStore.File.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("folder"u8); + + foreach(var folderItem in commonFileStore.Folder.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(folderItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(commonFileStore.Iid); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(commonFileStore.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(commonFileStore.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(commonFileStore.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing CommonFileStore for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(commonFileStore.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(commonFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in commonFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in commonFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("file"u8); + + foreach(var fileItem in commonFileStore.File.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("folder"u8); + + foreach(var folderItem in commonFileStore.Folder.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(folderItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(commonFileStore.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(commonFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(commonFileStore.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(commonFileStore.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(commonFileStore.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing CommonFileStore for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(commonFileStore.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(commonFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in commonFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in commonFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("file"u8); + + foreach(var fileItem in commonFileStore.File.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("folder"u8); + + foreach(var folderItem in commonFileStore.Folder.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(folderItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(commonFileStore.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(commonFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(commonFileStore.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(commonFileStore.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(commonFileStore.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(commonFileStore.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing CommonFileStore for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(commonFileStore.Actor.HasValue) + { + writer.WriteStringValue(commonFileStore.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(commonFileStore.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(commonFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in commonFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in commonFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("file"u8); + + foreach(var fileItem in commonFileStore.File.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("folder"u8); + + foreach(var folderItem in commonFileStore.Folder.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(folderItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(commonFileStore.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(commonFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(commonFileStore.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(commonFileStore.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(commonFileStore.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(commonFileStore.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/CompoundParameterTypeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/CompoundParameterTypeSerializer.cs index 09cc7998..7ab79241 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/CompoundParameterTypeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/CompoundParameterTypeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,393 +50,343 @@ namespace CDP4JsonSerializer public class CompoundParameterTypeSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not CompoundParameterType compoundParameterType) - { - throw new ArgumentException("The thing shall be a CompoundParameterType", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of CompoundParameterType since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing CompoundParameterType for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in compoundParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in compoundParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(compoundParameterType.ClassKind.ToString()); - writer.WriteStartArray("component"u8); - - foreach(var componentItem in compoundParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) + else { - writer.WriteOrderedItem(componentItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in compoundParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in compoundParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(compoundParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(compoundParameterType.IsDeprecated); - writer.WritePropertyName("isFinalized"u8); - writer.WriteBooleanValue(compoundParameterType.IsFinalized); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(compoundParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(compoundParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(compoundParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(compoundParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing CompoundParameterType for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in compoundParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in compoundParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(compoundParameterType.ClassKind.ToString()); - writer.WriteStartArray("component"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var componentItem in compoundParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteOrderedItem(componentItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in compoundParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "component": + var allowedVersionsForComponent = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in compoundParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForComponent.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("component"u8); - foreach(var excludedPersonItem in compoundParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListComponent) { - writer.WriteStringValue(excludedPersonItem); + foreach(var componentItem in objectListComponent.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(componentItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in compoundParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); + + if(value is IEnumerable objectListDefinition) + { + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(compoundParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(compoundParameterType.IsDeprecated); - writer.WritePropertyName("isFinalized"u8); - writer.WriteBooleanValue(compoundParameterType.IsFinalized); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(compoundParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(compoundParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(compoundParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(compoundParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(compoundParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing CompoundParameterType for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in compoundParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in compoundParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(compoundParameterType.ClassKind.ToString()); - writer.WriteStartArray("component"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var componentItem in compoundParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteOrderedItem(componentItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var definitionItem in compoundParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(definitionItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in compoundParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var excludedPersonItem in compoundParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(excludedPersonItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in compoundParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(compoundParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(compoundParameterType.IsDeprecated); - writer.WritePropertyName("isFinalized"u8); - writer.WriteBooleanValue(compoundParameterType.IsFinalized); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(compoundParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(compoundParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(compoundParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(compoundParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(compoundParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(compoundParameterType.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing CompoundParameterType for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(compoundParameterType.Actor.HasValue) + + if(value != null) { - writer.WriteStringValue(compoundParameterType.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in compoundParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in compoundParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(compoundParameterType.ClassKind.ToString()); - writer.WriteStartArray("component"u8); - - foreach(var componentItem in compoundParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) + if(value != null) { - writer.WriteOrderedItem(componentItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in compoundParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "isfinalized": + var allowedVersionsForIsFinalized = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in compoundParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsFinalized.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isFinalized"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in compoundParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in compoundParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(compoundParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(compoundParameterType.IsDeprecated); - writer.WritePropertyName("isFinalized"u8); - writer.WriteBooleanValue(compoundParameterType.IsFinalized); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(compoundParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(compoundParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(compoundParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(compoundParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(compoundParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(compoundParameterType.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -445,53 +394,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) + if(!allowedVersionsForName.Contains(requestedVersion)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + return; } + + writer.WritePropertyName("name"u8); - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + else { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -499,107 +446,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "component": - if(!AllowedVersionsPerProperty["component"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List { - return; - } - - writer.WriteStartArray("component"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListComponent) - { - foreach(var componentItem in objectListComponent.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(componentItem); - } - } - - writer.WriteEndArray(); - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) + if(value != null) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "symbol": + var allowedVersionsForSymbol = new List { - return; - } - - writer.WriteStartArray("hyperLink"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("symbol"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -607,17 +498,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isDeprecated"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -625,161 +522,347 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isfinalized": - if(!AllowedVersionsPerProperty["isFinalized"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the CompoundParameterType"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not CompoundParameterType compoundParameterType) + { + throw new ArgumentException("The thing shall be a CompoundParameterType", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of CompoundParameterType since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing CompoundParameterType for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in compoundParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("isFinalized"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in compoundParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(compoundParameterType.ClassKind.ToString()); + writer.WriteStartArray("component"u8); + + foreach(var componentItem in compoundParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(componentItem); } + writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in compoundParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in compoundParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(compoundParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(compoundParameterType.IsDeprecated); + writer.WritePropertyName("isFinalized"u8); + writer.WriteBooleanValue(compoundParameterType.IsFinalized); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(compoundParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(compoundParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(compoundParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(compoundParameterType.Symbol); break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing CompoundParameterType for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in compoundParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in compoundParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(compoundParameterType.ClassKind.ToString()); + writer.WriteStartArray("component"u8); + + foreach(var componentItem in compoundParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(componentItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in compoundParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in compoundParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in compoundParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in compoundParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(compoundParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(compoundParameterType.IsDeprecated); + writer.WritePropertyName("isFinalized"u8); + writer.WriteBooleanValue(compoundParameterType.IsFinalized); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(compoundParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(compoundParameterType.Name); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(compoundParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(compoundParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(compoundParameterType.Symbol); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing CompoundParameterType for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in compoundParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in compoundParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(compoundParameterType.ClassKind.ToString()); + writer.WriteStartArray("component"u8); + + foreach(var componentItem in compoundParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(componentItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in compoundParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in compoundParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in compoundParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in compoundParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(compoundParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(compoundParameterType.IsDeprecated); + writer.WritePropertyName("isFinalized"u8); + writer.WriteBooleanValue(compoundParameterType.IsFinalized); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(compoundParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(compoundParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(compoundParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(compoundParameterType.ShortName); writer.WritePropertyName("symbol"u8); - - if(value != null) + writer.WriteStringValue(compoundParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(compoundParameterType.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing CompoundParameterType for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(compoundParameterType.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(compoundParameterType.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in compoundParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in compoundParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(compoundParameterType.ClassKind.ToString()); + writer.WriteStartArray("component"u8); + + foreach(var componentItem in compoundParameterType.Component.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(componentItem); } + writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in compoundParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in compoundParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in compoundParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in compoundParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(compoundParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(compoundParameterType.IsDeprecated); + writer.WritePropertyName("isFinalized"u8); + writer.WriteBooleanValue(compoundParameterType.IsFinalized); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(compoundParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(compoundParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(compoundParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(compoundParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(compoundParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(compoundParameterType.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the CompoundParameterType"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "component", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isFinalized", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ConstantSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ConstantSerializer.cs index 412e656b..6e2f969c 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ConstantSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ConstantSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,393 +50,391 @@ namespace CDP4JsonSerializer public class ConstantSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not Constant constant) - { - throw new ArgumentException("The thing shall be a Constant", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Constant since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Constant for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in constant.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var categoryItem in constant.Category.OrderBy(x => x, this.GuidComparer)) + break; + case "alias": + var allowedVersionsForAlias = new List { - writer.WriteStringValue(categoryItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WriteStartArray("alias"u8); + + if(value is IEnumerable objectListAlias) + { + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + } - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(constant.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in constant.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + if(value is IEnumerable objectListCategory) + { + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in constant.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(constant.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(constant.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(constant.Name); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(constant.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(constant.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(constant.Scale.HasValue) + if(value != null) { - writer.WriteStringValue(constant.Scale.Value); + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(constant.ShortName); - writer.WriteString("value"u8, constant.Value.ToJsonString()); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Constant for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in constant.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("definition"u8); - foreach(var categoryItem in constant.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(categoryItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(constant.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in constant.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); - foreach(var excludedDomainItem in constant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in constant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var hyperLinkItem in constant.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(hyperLinkItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(constant.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(constant.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(constant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(constant.Name); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(constant.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(constant.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(constant.Scale.HasValue) + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List { - writer.WriteStringValue(constant.Scale.Value); - } - else + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteNullValue(); + return; } - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(constant.ShortName); - writer.WriteString("value"u8, constant.Value.ToJsonString()); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Constant for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var aliasItem in constant.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(aliasItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in constant.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(constant.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in constant.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in constant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in constant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in constant.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(constant.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(constant.IsDeprecated); writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(constant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(constant.Name); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(constant.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(constant.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(constant.Scale.HasValue) + + if(value != null) { - writer.WriteStringValue(constant.Scale.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(constant.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(constant.ThingPreference); - writer.WriteString("value"u8, constant.Value.ToJsonString()); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Constant for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(constant.Actor.HasValue) + if(!allowedVersionsForName.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("name"u8); + + if(value != null) { - writer.WriteStringValue(constant.Actor.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in constant.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "parametertype": + var allowedVersionsForParameterType = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in constant.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForParameterType.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("parameterType"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(constant.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in constant.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in constant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in constant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in constant.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(constant.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(constant.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(constant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(constant.Name); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(constant.ParameterType); writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(constant.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(constant.Scale.HasValue) + + if(value != null) { - writer.WriteStringValue(constant.Scale.Value); + writer.WriteNumberValue((int)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(constant.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(constant.ThingPreference); - writer.WriteString("value"u8, constant.Value.ToJsonString()); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "scale": + var allowedVersionsForScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForScale.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("scale"u8); if(value != null) { @@ -449,53 +446,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + return; } + + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + else { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -503,277 +496,371 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "value": + var allowedVersionsForValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValue.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); + writer.WriteString("value"u8, ((ValueArray)value).ToJsonString()); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the Constant"); + } + } - if(value is IEnumerable objectListDefinition) + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not Constant constant) + { + throw new ArgumentException("The thing shall be a Constant", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Constant since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Constant for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in constant.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in constant.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(constant.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var definitionItem in constant.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in constant.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(constant.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(constant.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(constant.Name); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(constant.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(constant.RevisionNumber); + writer.WritePropertyName("scale"u8); - if(value is IEnumerable objectListExcludedPerson) + if(constant.Scale.HasValue) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(constant.Scale.Value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(constant.ShortName); + writer.WriteString("value"u8, constant.Value.ToJsonString()); break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Constant for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in constant.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var categoryItem in constant.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(constant.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in constant.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in constant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in constant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in constant.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(constant.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteBooleanValue(constant.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(constant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(constant.Name); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(constant.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(constant.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(constant.Scale.HasValue) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(constant.Scale.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(constant.ShortName); + writer.WriteString("value"u8, constant.Value.ToJsonString()); break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Constant for Version 1.2.0"); + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + foreach(var aliasItem in constant.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in constant.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(constant.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in constant.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in constant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in constant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in constant.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(constant.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(constant.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(constant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(constant.Name); writer.WritePropertyName("parameterType"u8); - - if(value != null) + writer.WriteStringValue(constant.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(constant.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(constant.Scale.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(constant.Scale.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(constant.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(constant.ThingPreference); + writer.WriteString("value"u8, constant.Value.ToJsonString()); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Constant for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(constant.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(constant.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "scale": - if(!AllowedVersionsPerProperty["scale"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("scale"u8); - - if(value != null) + foreach(var aliasItem in constant.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in constant.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(constant.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in constant.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in constant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in constant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in constant.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(constant.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(constant.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(constant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(constant.Name); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(constant.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(constant.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(constant.Scale.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(constant.Scale.Value); } else { writer.WriteNullValue(); } - break; - case "value": - if(!AllowedVersionsPerProperty["value"].Contains(requestedVersion)) - { - return; - } - - writer.WriteString("value"u8, ((ValueArray)value).ToJsonString()); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(constant.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(constant.ThingPreference); + writer.WriteString("value"u8, constant.Value.ToJsonString()); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the Constant"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "scale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "value", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ContractChangeNoticeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ContractChangeNoticeSerializer.cs index 8d6aaf3d..494f45e3 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ContractChangeNoticeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ContractChangeNoticeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,460 +50,330 @@ namespace CDP4JsonSerializer public class ContractChangeNoticeSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ContractChangeNotice contractChangeNotice) - { - throw new ArgumentException("The thing shall be a ContractChangeNotice", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ContractChangeNotice since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ContractChangeNotice for Version 1.1.0"); - writer.WriteStartArray("approvedBy"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var approvedByItem in contractChangeNotice.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(contractChangeNotice.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in contractChangeNotice.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("changeProposal"u8); - writer.WriteStringValue(contractChangeNotice.ChangeProposal); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(contractChangeNotice.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(contractChangeNotice.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(contractChangeNotice.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(contractChangeNotice.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "approvedby": + var allowedVersionsForApprovedBy = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in contractChangeNotice.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForApprovedBy.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("approvedBy"u8); - foreach(var excludedDomainItem in contractChangeNotice.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListApprovedBy) { - writer.WriteStringValue(excludedDomainItem); + foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(approvedByItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "author": + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in contractChangeNotice.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("author"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(contractChangeNotice.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(contractChangeNotice.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(contractChangeNotice.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(contractChangeNotice.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(contractChangeNotice.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(contractChangeNotice.PrimaryAnnotatedThing.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var relatedThingItem in contractChangeNotice.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(relatedThingItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(contractChangeNotice.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(contractChangeNotice.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + writer.WriteStartArray("category"u8); - foreach(var sourceAnnotationItem in contractChangeNotice.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(sourceAnnotationItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(contractChangeNotice.Status.ToString()); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(contractChangeNotice.Title); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ContractChangeNotice for Version 1.2.0"); - writer.WriteStartArray("approvedBy"u8); + case "changeproposal": + var allowedVersionsForChangeProposal = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in contractChangeNotice.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForChangeProposal.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("changeProposal"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(contractChangeNotice.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in contractChangeNotice.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("changeProposal"u8); - writer.WriteStringValue(contractChangeNotice.ChangeProposal); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(contractChangeNotice.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(contractChangeNotice.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(contractChangeNotice.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(contractChangeNotice.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "classification": + var allowedVersionsForClassification = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in contractChangeNotice.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassification.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in contractChangeNotice.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in contractChangeNotice.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(contractChangeNotice.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(contractChangeNotice.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(contractChangeNotice.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(contractChangeNotice.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(contractChangeNotice.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(contractChangeNotice.PrimaryAnnotatedThing.Value); + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in contractChangeNotice.RelatedThing.OrderBy(x => x, this.GuidComparer)) + break; + case "content": + var allowedVersionsForContent = new List { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(contractChangeNotice.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(contractChangeNotice.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var sourceAnnotationItem in contractChangeNotice.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContent.Contains(requestedVersion)) { - writer.WriteStringValue(sourceAnnotationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("content"u8); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(contractChangeNotice.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(contractChangeNotice.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(contractChangeNotice.Title); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ContractChangeNotice for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(contractChangeNotice.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(contractChangeNotice.Actor.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("approvedBy"u8); + break; + case "createdon": + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in contractChangeNotice.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("createdOn"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(contractChangeNotice.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in contractChangeNotice.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("changeProposal"u8); - writer.WriteStringValue(contractChangeNotice.ChangeProposal); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(contractChangeNotice.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(contractChangeNotice.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(contractChangeNotice.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(contractChangeNotice.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in contractChangeNotice.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in contractChangeNotice.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in contractChangeNotice.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(contractChangeNotice.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(contractChangeNotice.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(contractChangeNotice.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(contractChangeNotice.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(contractChangeNotice.PrimaryAnnotatedThing.HasValue) - { - writer.WriteStringValue(contractChangeNotice.PrimaryAnnotatedThing.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in contractChangeNotice.RelatedThing.OrderBy(x => x, this.GuidComparer)) + break; + case "discussion": + var allowedVersionsForDiscussion = new List { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(contractChangeNotice.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(contractChangeNotice.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var sourceAnnotationItem in contractChangeNotice.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDiscussion.Contains(requestedVersion)) { - writer.WriteStringValue(sourceAnnotationItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("status"u8); - writer.WriteStringValue(contractChangeNotice.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(contractChangeNotice.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(contractChangeNotice.Title); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + writer.WriteStartArray("discussion"u8); - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(value is IEnumerable objectListDiscussion) { - return; + foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } } - - writer.WritePropertyName("actor"u8); - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteNullValue(); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - break; - case "approvedby": - if(!AllowedVersionsPerProperty["approvedBy"].Contains(requestedVersion)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } - writer.WriteStartArray("approvedBy"u8); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListApprovedBy) + if(value is IEnumerable objectListExcludedDomain) { - foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(approvedByItem); + writer.WriteStringValue(excludedDomainItem); } } writer.WriteEndArray(); break; - case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("author"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + case "excludedperson": + var allowedVersionsForExcludedPerson = new List { - writer.WriteNullValue(); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListExcludedPerson) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(excludedPersonItem); } } writer.WriteEndArray(); break; - case "changeproposal": - if(!AllowedVersionsPerProperty["changeProposal"].Contains(requestedVersion)) + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } - writer.WritePropertyName("changeProposal"u8); + writer.WritePropertyName("iid"u8); if(value != null) { @@ -516,17 +385,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "classification": - if(!AllowedVersionsPerProperty["classification"].Contains(requestedVersion)) + case "languagecode": + var allowedVersionsForLanguageCode = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classification"u8); + writer.WritePropertyName("languageCode"u8); if(value != null) { - writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -534,17 +410,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -552,17 +435,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + case "owner": + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } - writer.WritePropertyName("content"u8); + writer.WritePropertyName("owner"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue((Guid)value); } else { @@ -570,17 +460,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + case "primaryannotatedthing": + var allowedVersionsForPrimaryAnnotatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPrimaryAnnotatedThing.Contains(requestedVersion)) { return; } - writer.WritePropertyName("createdOn"u8); + writer.WritePropertyName("primaryAnnotatedThing"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((Guid)value); } else { @@ -588,71 +485,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "discussion": - if(!AllowedVersionsPerProperty["discussion"].Contains(requestedVersion)) + case "relatedthing": + var allowedVersionsForRelatedThing = new List { - return; - } - - writer.WriteStartArray("discussion"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDiscussion) - { - foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForRelatedThing.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("relatedThing"u8); - if(value is IEnumerable objectListExcludedDomain) + if(value is IEnumerable objectListRelatedThing) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(relatedThingItem); } } writer.WriteEndArray(); break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -660,13 +535,20 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("languageCode"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { @@ -678,17 +560,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "sourceannotation": + var allowedVersionsForSourceAnnotation = new List { - return; - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + if(!allowedVersionsForSourceAnnotation.Contains(requestedVersion)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + return; + } + + writer.WriteStartArray("sourceAnnotation"u8); + + if(value is IEnumerable objectListSourceAnnotation) + { + foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); + } + } + + writer.WriteEndArray(); + break; + case "status": + var allowedVersionsForStatus = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStatus.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("status"u8); + + if(value != null) + { + writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); } else { @@ -696,17 +610,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("owner"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -714,17 +634,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "primaryannotatedthing": - if(!AllowedVersionsPerProperty["primaryAnnotatedThing"].Contains(requestedVersion)) + case "title": + var allowedVersionsForTitle = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTitle.Contains(requestedVersion)) { return; } - writer.WritePropertyName("primaryAnnotatedThing"u8); + writer.WritePropertyName("title"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -732,167 +659,351 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "relatedthing": - if(!AllowedVersionsPerProperty["relatedThing"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ContractChangeNotice"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ContractChangeNotice contractChangeNotice) + { + throw new ArgumentException("The thing shall be a ContractChangeNotice", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ContractChangeNotice since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ContractChangeNotice for Version 1.1.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in contractChangeNotice.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WriteStartArray("relatedThing"u8); + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(contractChangeNotice.Author); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListRelatedThing) + foreach(var categoryItem in contractChangeNotice.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WritePropertyName("changeProposal"u8); + writer.WriteStringValue(contractChangeNotice.ChangeProposal); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(contractChangeNotice.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(contractChangeNotice.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(contractChangeNotice.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(contractChangeNotice.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in contractChangeNotice.Discussion.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(discussionItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in contractChangeNotice.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in contractChangeNotice.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(contractChangeNotice.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(contractChangeNotice.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(contractChangeNotice.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(contractChangeNotice.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(contractChangeNotice.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(contractChangeNotice.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in contractChangeNotice.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(contractChangeNotice.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(contractChangeNotice.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in contractChangeNotice.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(sourceAnnotationItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(contractChangeNotice.Status.ToString()); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(contractChangeNotice.Title); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ContractChangeNotice for Version 1.2.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in contractChangeNotice.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(approvedByItem); } - break; - case "sourceannotation": - if(!AllowedVersionsPerProperty["sourceAnnotation"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(contractChangeNotice.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in contractChangeNotice.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WriteStartArray("sourceAnnotation"u8); + writer.WriteEndArray(); + writer.WritePropertyName("changeProposal"u8); + writer.WriteStringValue(contractChangeNotice.ChangeProposal); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(contractChangeNotice.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(contractChangeNotice.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(contractChangeNotice.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(contractChangeNotice.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); - if(value is IEnumerable objectListSourceAnnotation) + foreach(var discussionItem in contractChangeNotice.Discussion.OrderBy(x => x, this.GuidComparer)) { - foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sourceAnnotationItem); - } + writer.WriteStringValue(discussionItem); } - + writer.WriteEndArray(); - break; - case "status": - if(!AllowedVersionsPerProperty["status"].Contains(requestedVersion)) + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in contractChangeNotice.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("status"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in contractChangeNotice.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(contractChangeNotice.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(contractChangeNotice.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(contractChangeNotice.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(contractChangeNotice.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(contractChangeNotice.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(contractChangeNotice.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in contractChangeNotice.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(contractChangeNotice.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(contractChangeNotice.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in contractChangeNotice.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); } + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(contractChangeNotice.Status.ToString()); writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteStringValue(contractChangeNotice.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(contractChangeNotice.Title); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ContractChangeNotice for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(contractChangeNotice.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(contractChangeNotice.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "title": - if(!AllowedVersionsPerProperty["title"].Contains(requestedVersion)) + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in contractChangeNotice.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("title"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(contractChangeNotice.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in contractChangeNotice.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("changeProposal"u8); + writer.WriteStringValue(contractChangeNotice.ChangeProposal); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(contractChangeNotice.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(contractChangeNotice.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(contractChangeNotice.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(contractChangeNotice.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in contractChangeNotice.Discussion.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in contractChangeNotice.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in contractChangeNotice.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(contractChangeNotice.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(contractChangeNotice.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(contractChangeNotice.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(contractChangeNotice.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(contractChangeNotice.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(contractChangeNotice.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in contractChangeNotice.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(contractChangeNotice.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(contractChangeNotice.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in contractChangeNotice.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(contractChangeNotice.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(contractChangeNotice.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(contractChangeNotice.Title); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ContractChangeNotice"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "approvedBy", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "changeProposal", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classification", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "discussion", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "primaryAnnotatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "relatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "sourceAnnotation", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "status", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "title", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/CyclicRatioScaleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/CyclicRatioScaleSerializer.cs index e8a0f05f..74aba1f5 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/CyclicRatioScaleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/CyclicRatioScaleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,449 +50,292 @@ namespace CDP4JsonSerializer public class CyclicRatioScaleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not CyclicRatioScale cyclicRatioScale) - { - throw new ArgumentException("The thing shall be a CyclicRatioScale", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of CyclicRatioScale since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing CyclicRatioScale for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in cyclicRatioScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(cyclicRatioScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in cyclicRatioScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in cyclicRatioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(cyclicRatioScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var mappingToReferenceScaleItem in cyclicRatioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(mappingToReferenceScaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(cyclicRatioScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(cyclicRatioScale.MinimumPermissibleValue); - writer.WritePropertyName("modulus"u8); - writer.WriteStringValue(cyclicRatioScale.Modulus); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(cyclicRatioScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(cyclicRatioScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(cyclicRatioScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(cyclicRatioScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(cyclicRatioScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(cyclicRatioScale.ShortName); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(cyclicRatioScale.Unit); - writer.WriteStartArray("valueDefinition"u8); + writer.WriteStartArray("alias"u8); - foreach(var valueDefinitionItem in cyclicRatioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(valueDefinitionItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing CyclicRatioScale for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in cyclicRatioScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(cyclicRatioScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in cyclicRatioScale.Definition.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in cyclicRatioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in cyclicRatioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in cyclicRatioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(cyclicRatioScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var mappingToReferenceScaleItem in cyclicRatioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(mappingToReferenceScaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(cyclicRatioScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(cyclicRatioScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(cyclicRatioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("modulus"u8); - writer.WriteStringValue(cyclicRatioScale.Modulus); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(cyclicRatioScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(cyclicRatioScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(cyclicRatioScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(cyclicRatioScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(cyclicRatioScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(cyclicRatioScale.ShortName); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(cyclicRatioScale.Unit); - writer.WriteStartArray("valueDefinition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var valueDefinitionItem in cyclicRatioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(valueDefinitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing CyclicRatioScale for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in cyclicRatioScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(cyclicRatioScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var definitionItem in cyclicRatioScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(definitionItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in cyclicRatioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var excludedPersonItem in cyclicRatioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(excludedPersonItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in cyclicRatioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(cyclicRatioScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); - - foreach(var mappingToReferenceScaleItem in cyclicRatioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(mappingToReferenceScaleItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(cyclicRatioScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(cyclicRatioScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(cyclicRatioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("modulus"u8); - writer.WriteStringValue(cyclicRatioScale.Modulus); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(cyclicRatioScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(cyclicRatioScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(cyclicRatioScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(cyclicRatioScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(cyclicRatioScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(cyclicRatioScale.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(cyclicRatioScale.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(cyclicRatioScale.Unit); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in cyclicRatioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueDefinitionItem); - } - - writer.WriteEndArray(); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing CyclicRatioScale for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(cyclicRatioScale.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(cyclicRatioScale.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in cyclicRatioScale.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(cyclicRatioScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in cyclicRatioScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in cyclicRatioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in cyclicRatioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "ismaximuminclusive": + var allowedVersionsForIsMaximumInclusive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in cyclicRatioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsMaximumInclusive.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(cyclicRatioScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsDeprecated); writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(cyclicRatioScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); - - foreach(var mappingToReferenceScaleItem in cyclicRatioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(mappingToReferenceScaleItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(cyclicRatioScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(cyclicRatioScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(cyclicRatioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("modulus"u8); - writer.WriteStringValue(cyclicRatioScale.Modulus); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(cyclicRatioScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(cyclicRatioScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(cyclicRatioScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(cyclicRatioScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(cyclicRatioScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(cyclicRatioScale.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(cyclicRatioScale.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(cyclicRatioScale.Unit); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in cyclicRatioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(valueDefinitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "isminimuminclusive": + var allowedVersionsForIsMinimumInclusive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForIsMinimumInclusive.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("isMinimumInclusive"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteBooleanValue((bool)value); } else { @@ -501,35 +343,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "mappingtoreferencescale": + var allowedVersionsForMappingToReferenceScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMappingToReferenceScale.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("mappingToReferenceScale"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListMappingToReferenceScale) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var mappingToReferenceScaleItem in objectListMappingToReferenceScale.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteStringValue(mappingToReferenceScaleItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "maximumpermissiblevalue": + var allowedVersionsForMaximumPermissibleValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMaximumPermissibleValue.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("maximumPermissibleValue"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -537,89 +395,102 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "minimumpermissiblevalue": + var allowedVersionsForMinimumPermissibleValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMinimumPermissibleValue.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + writer.WritePropertyName("minimumPermissibleValue"u8); + + if(value != null) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListExcludedDomain) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + return; } + + writer.WritePropertyName("modifiedOn"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "modulus": + var allowedVersionsForModulus = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModulus.Contains(requestedVersion)) { return; } - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) + writer.WritePropertyName("modulus"u8); + + if(value != null) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -627,17 +498,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "negativevalueconnotation": + var allowedVersionsForNegativeValueConnotation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNegativeValueConnotation.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isDeprecated"u8); + writer.WritePropertyName("negativeValueConnotation"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -645,17 +524,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "ismaximuminclusive": - if(!AllowedVersionsPerProperty["isMaximumInclusive"].Contains(requestedVersion)) + case "numberset": + var allowedVersionsForNumberSet = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNumberSet.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isMaximumInclusive"u8); + writer.WritePropertyName("numberSet"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(((NumberSetKind)value).ToString()); } else { @@ -663,17 +550,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isminimuminclusive": - if(!AllowedVersionsPerProperty["isMinimumInclusive"].Contains(requestedVersion)) + case "positivevalueconnotation": + var allowedVersionsForPositiveValueConnotation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPositiveValueConnotation.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isMinimumInclusive"u8); + writer.WritePropertyName("positiveValueConnotation"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -681,35 +576,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "mappingtoreferencescale": - if(!AllowedVersionsPerProperty["mappingToReferenceScale"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } - - writer.WriteStartArray("mappingToReferenceScale"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListMappingToReferenceScale) - { - foreach(var mappingToReferenceScaleItem in objectListMappingToReferenceScale.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(mappingToReferenceScaleItem); - } - } - - writer.WriteEndArray(); - break; - case "maximumpermissiblevalue": - if(!AllowedVersionsPerProperty["maximumPermissibleValue"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue((int)value); } else { @@ -717,13 +602,21 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "minimumpermissiblevalue": - if(!AllowedVersionsPerProperty["minimumPermissibleValue"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { @@ -735,17 +628,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((string)value); } else { @@ -753,17 +652,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modulus": - if(!AllowedVersionsPerProperty["modulus"].Contains(requestedVersion)) + case "unit": + var allowedVersionsForUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUnit.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modulus"u8); + writer.WritePropertyName("unit"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue((Guid)value); } else { @@ -771,204 +678,429 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + case "valuedefinition": + var allowedVersionsForValueDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueDefinition.Contains(requestedVersion)) { return; } - writer.WritePropertyName("name"u8); + writer.WriteStartArray("valueDefinition"u8); + + if(value is IEnumerable objectListValueDefinition) + { + foreach(var valueDefinitionItem in objectListValueDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueDefinitionItem); + } + } - if(value != null) + writer.WriteEndArray(); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the CyclicRatioScale"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not CyclicRatioScale cyclicRatioScale) + { + throw new ArgumentException("The thing shall be a CyclicRatioScale", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of CyclicRatioScale since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing CyclicRatioScale for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in cyclicRatioScale.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(cyclicRatioScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in cyclicRatioScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "negativevalueconnotation": - if(!AllowedVersionsPerProperty["negativeValueConnotation"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in cyclicRatioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("negativeValueConnotation"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(cyclicRatioScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in cyclicRatioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(mappingToReferenceScaleItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(cyclicRatioScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(cyclicRatioScale.MinimumPermissibleValue); + writer.WritePropertyName("modulus"u8); + writer.WriteStringValue(cyclicRatioScale.Modulus); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(cyclicRatioScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(cyclicRatioScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(cyclicRatioScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(cyclicRatioScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(cyclicRatioScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(cyclicRatioScale.ShortName); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(cyclicRatioScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in cyclicRatioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(valueDefinitionItem); } + writer.WriteEndArray(); break; - case "numberset": - if(!AllowedVersionsPerProperty["numberSet"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing CyclicRatioScale for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in cyclicRatioScale.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("numberSet"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(cyclicRatioScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in cyclicRatioScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((NumberSetKind)value).ToString()); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in cyclicRatioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "positivevalueconnotation": - if(!AllowedVersionsPerProperty["positiveValueConnotation"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in cyclicRatioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("positiveValueConnotation"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in cyclicRatioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(cyclicRatioScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in cyclicRatioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(mappingToReferenceScaleItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(cyclicRatioScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(cyclicRatioScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(cyclicRatioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("modulus"u8); + writer.WriteStringValue(cyclicRatioScale.Modulus); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(cyclicRatioScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(cyclicRatioScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(cyclicRatioScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(cyclicRatioScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(cyclicRatioScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(cyclicRatioScale.ShortName); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(cyclicRatioScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in cyclicRatioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(valueDefinitionItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing CyclicRatioScale for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in cyclicRatioScale.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(cyclicRatioScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in cyclicRatioScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in cyclicRatioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in cyclicRatioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in cyclicRatioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(cyclicRatioScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in cyclicRatioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(mappingToReferenceScaleItem); } + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(cyclicRatioScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(cyclicRatioScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(cyclicRatioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("modulus"u8); + writer.WriteStringValue(cyclicRatioScale.Modulus); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(cyclicRatioScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(cyclicRatioScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(cyclicRatioScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(cyclicRatioScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(cyclicRatioScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(cyclicRatioScale.ShortName); writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteStringValue(cyclicRatioScale.ThingPreference); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(cyclicRatioScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in cyclicRatioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(valueDefinitionItem); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing CyclicRatioScale for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(cyclicRatioScale.Actor.HasValue) + { + writer.WriteStringValue(cyclicRatioScale.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "unit": - if(!AllowedVersionsPerProperty["unit"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in cyclicRatioScale.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("unit"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(cyclicRatioScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in cyclicRatioScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in cyclicRatioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "valuedefinition": - if(!AllowedVersionsPerProperty["valueDefinition"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in cyclicRatioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in cyclicRatioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(cyclicRatioScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(cyclicRatioScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in cyclicRatioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(mappingToReferenceScaleItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(cyclicRatioScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(cyclicRatioScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(cyclicRatioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("modulus"u8); + writer.WriteStringValue(cyclicRatioScale.Modulus); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(cyclicRatioScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(cyclicRatioScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(cyclicRatioScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(cyclicRatioScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(cyclicRatioScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(cyclicRatioScale.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(cyclicRatioScale.ThingPreference); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(cyclicRatioScale.Unit); writer.WriteStartArray("valueDefinition"u8); - if(value is IEnumerable objectListValueDefinition) + foreach(var valueDefinitionItem in cyclicRatioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - foreach(var valueDefinitionItem in objectListValueDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueDefinitionItem); - } + writer.WriteStringValue(valueDefinitionItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the CyclicRatioScale"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isMaximumInclusive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isMinimumInclusive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "mappingToReferenceScale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "maximumPermissibleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "minimumPermissibleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modulus", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "negativeValueConnotation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "numberSet", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "positiveValueConnotation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "unit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "valueDefinition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DateParameterTypeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DateParameterTypeSerializer.cs index 9e479ed0..9835c3d5 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DateParameterTypeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DateParameterTypeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,349 +50,317 @@ namespace CDP4JsonSerializer public class DateParameterTypeSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not DateParameterType dateParameterType) - { - throw new ArgumentException("The thing shall be a DateParameterType", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DateParameterType since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing DateParameterType for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in dateParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in dateParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(dateParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in dateParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in dateParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(dateParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(dateParameterType.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(dateParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(dateParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(dateParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(dateParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing DateParameterType for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in dateParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in dateParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(dateParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in dateParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in dateParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in dateParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in dateParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(dateParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(dateParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(dateParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(dateParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(dateParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(dateParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(dateParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DateParameterType for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in dateParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in dateParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(dateParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in dateParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in dateParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in dateParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in dateParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(dateParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(dateParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(dateParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(dateParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(dateParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(dateParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(dateParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(dateParameterType.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DateParameterType for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(dateParameterType.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(dateParameterType.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in dateParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in dateParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(dateParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in dateParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in dateParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in dateParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in dateParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(dateParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(dateParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(dateParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(dateParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(dateParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(dateParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(dateParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(dateParameterType.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -401,53 +368,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + return; } + + writer.WritePropertyName("revisionNumber"u8); - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteNumberValue((int)value); } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + else { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -455,249 +420,357 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "symbol": + var allowedVersionsForSymbol = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + return; } + + writer.WritePropertyName("symbol"u8); - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) + else { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("hyperLink"u8); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the DateParameterType"); + } + } - if(value is IEnumerable objectListHyperLink) + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not DateParameterType dateParameterType) + { + throw new ArgumentException("The thing shall be a DateParameterType", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DateParameterType since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing DateParameterType for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in dateParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("category"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + foreach(var categoryItem in dateParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(dateParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in dateParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in dateParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(dateParameterType.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteBooleanValue(dateParameterType.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(dateParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(dateParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(dateParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(dateParameterType.Symbol); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing DateParameterType for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in dateParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in dateParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(dateParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in dateParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in dateParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in dateParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in dateParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(dateParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(dateParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(dateParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteStringValue(dateParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(dateParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(dateParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(dateParameterType.Symbol); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DateParameterType for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in dateParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in dateParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(dateParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in dateParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in dateParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in dateParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in dateParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(dateParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(dateParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(dateParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(dateParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(dateParameterType.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(dateParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(dateParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(dateParameterType.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DateParameterType for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(dateParameterType.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(dateParameterType.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in dateParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("symbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in dateParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(dateParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in dateParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in dateParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in dateParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in dateParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(dateParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(dateParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(dateParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(dateParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(dateParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(dateParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(dateParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(dateParameterType.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the DateParameterType"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DateTimeParameterTypeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DateTimeParameterTypeSerializer.cs index c75c8db2..403c9796 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DateTimeParameterTypeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DateTimeParameterTypeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,349 +50,317 @@ namespace CDP4JsonSerializer public class DateTimeParameterTypeSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not DateTimeParameterType dateTimeParameterType) - { - throw new ArgumentException("The thing shall be a DateTimeParameterType", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DateTimeParameterType since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing DateTimeParameterType for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in dateTimeParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in dateTimeParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(dateTimeParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in dateTimeParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in dateTimeParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(dateTimeParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(dateTimeParameterType.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(dateTimeParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(dateTimeParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(dateTimeParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(dateTimeParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing DateTimeParameterType for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in dateTimeParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in dateTimeParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(dateTimeParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in dateTimeParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in dateTimeParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in dateTimeParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in dateTimeParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(dateTimeParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(dateTimeParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(dateTimeParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(dateTimeParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(dateTimeParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(dateTimeParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(dateTimeParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DateTimeParameterType for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in dateTimeParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in dateTimeParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(dateTimeParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in dateTimeParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in dateTimeParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in dateTimeParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in dateTimeParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(dateTimeParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(dateTimeParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(dateTimeParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(dateTimeParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(dateTimeParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(dateTimeParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(dateTimeParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(dateTimeParameterType.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DateTimeParameterType for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(dateTimeParameterType.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(dateTimeParameterType.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in dateTimeParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in dateTimeParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(dateTimeParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in dateTimeParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in dateTimeParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in dateTimeParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in dateTimeParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(dateTimeParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(dateTimeParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(dateTimeParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(dateTimeParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(dateTimeParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(dateTimeParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(dateTimeParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(dateTimeParameterType.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -401,53 +368,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + return; } + + writer.WritePropertyName("revisionNumber"u8); - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteNumberValue((int)value); } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + else { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -455,249 +420,357 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "symbol": + var allowedVersionsForSymbol = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + return; } + + writer.WritePropertyName("symbol"u8); - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) + else { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("hyperLink"u8); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the DateTimeParameterType"); + } + } - if(value is IEnumerable objectListHyperLink) + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not DateTimeParameterType dateTimeParameterType) + { + throw new ArgumentException("The thing shall be a DateTimeParameterType", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DateTimeParameterType since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing DateTimeParameterType for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in dateTimeParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("category"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + foreach(var categoryItem in dateTimeParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(dateTimeParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in dateTimeParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in dateTimeParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(dateTimeParameterType.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteBooleanValue(dateTimeParameterType.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(dateTimeParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(dateTimeParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(dateTimeParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(dateTimeParameterType.Symbol); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing DateTimeParameterType for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in dateTimeParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in dateTimeParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(dateTimeParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in dateTimeParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in dateTimeParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in dateTimeParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in dateTimeParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(dateTimeParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(dateTimeParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(dateTimeParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteStringValue(dateTimeParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(dateTimeParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(dateTimeParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(dateTimeParameterType.Symbol); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DateTimeParameterType for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in dateTimeParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in dateTimeParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(dateTimeParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in dateTimeParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in dateTimeParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in dateTimeParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in dateTimeParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(dateTimeParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(dateTimeParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(dateTimeParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(dateTimeParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(dateTimeParameterType.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(dateTimeParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(dateTimeParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(dateTimeParameterType.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DateTimeParameterType for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(dateTimeParameterType.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(dateTimeParameterType.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in dateTimeParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("symbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in dateTimeParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(dateTimeParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in dateTimeParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in dateTimeParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in dateTimeParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in dateTimeParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(dateTimeParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(dateTimeParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(dateTimeParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(dateTimeParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(dateTimeParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(dateTimeParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(dateTimeParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(dateTimeParameterType.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the DateTimeParameterType"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DecompositionRuleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DecompositionRuleSerializer.cs index 1bcb6fc1..9f49314e 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DecompositionRuleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DecompositionRuleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,401 +50,369 @@ namespace CDP4JsonSerializer public class DecompositionRuleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not DecompositionRule decompositionRule) - { - throw new ArgumentException("The thing shall be a DecompositionRule", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DecompositionRule since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing DecompositionRule for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in decompositionRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(decompositionRule.ClassKind.ToString()); - writer.WriteStartArray("containedCategory"u8); - - foreach(var containedCategoryItem in decompositionRule.ContainedCategory.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(containedCategoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("containingCategory"u8); - writer.WriteStringValue(decompositionRule.ContainingCategory); - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in decompositionRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("alias"u8); + + if(value is IEnumerable objectListAlias) + { + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in decompositionRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(decompositionRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(decompositionRule.IsDeprecated); - writer.WritePropertyName("maxContained"u8); - - if(decompositionRule.MaxContained.HasValue) + if(value != null) { - writer.WriteNumberValue(decompositionRule.MaxContained.Value); + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WritePropertyName("minContained"u8); - writer.WriteNumberValue(decompositionRule.MinContained); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(decompositionRule.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(decompositionRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(decompositionRule.ShortName); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing DecompositionRule for Version 1.1.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in decompositionRule.Alias.OrderBy(x => x, this.GuidComparer)) + case "containedcategory": + var allowedVersionsForContainedCategory = new List { - writer.WriteStringValue(aliasItem); - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(decompositionRule.ClassKind.ToString()); - writer.WriteStartArray("containedCategory"u8); - - foreach(var containedCategoryItem in decompositionRule.ContainedCategory.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContainedCategory.Contains(requestedVersion)) { - writer.WriteStringValue(containedCategoryItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("containingCategory"u8); - writer.WriteStringValue(decompositionRule.ContainingCategory); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("containedCategory"u8); - foreach(var definitionItem in decompositionRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListContainedCategory) { - writer.WriteStringValue(definitionItem); + foreach(var containedCategoryItem in objectListContainedCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(containedCategoryItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in decompositionRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in decompositionRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "containingcategory": + var allowedVersionsForContainingCategory = new List { - writer.WriteStringValue(excludedPersonItem); - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in decompositionRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContainingCategory.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("containingCategory"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(decompositionRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(decompositionRule.IsDeprecated); - writer.WritePropertyName("maxContained"u8); - - if(decompositionRule.MaxContained.HasValue) + if(value != null) { - writer.WriteNumberValue(decompositionRule.MaxContained.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("minContained"u8); - writer.WriteNumberValue(decompositionRule.MinContained); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(decompositionRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(decompositionRule.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(decompositionRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(decompositionRule.ShortName); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DecompositionRule for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in decompositionRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(decompositionRule.ClassKind.ToString()); - writer.WriteStartArray("containedCategory"u8); + writer.WriteStartArray("definition"u8); - foreach(var containedCategoryItem in decompositionRule.ContainedCategory.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(containedCategoryItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("containingCategory"u8); - writer.WriteStringValue(decompositionRule.ContainingCategory); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in decompositionRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); - foreach(var excludedDomainItem in decompositionRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in decompositionRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var hyperLinkItem in decompositionRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(hyperLinkItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(decompositionRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(decompositionRule.IsDeprecated); - writer.WritePropertyName("maxContained"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(decompositionRule.MaxContained.HasValue) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteNumberValue(decompositionRule.MaxContained.Value); + return; } - else + + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) { - writer.WriteNullValue(); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WritePropertyName("minContained"u8); - writer.WriteNumberValue(decompositionRule.MinContained); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(decompositionRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(decompositionRule.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(decompositionRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(decompositionRule.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(decompositionRule.ThingPreference); + + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DecompositionRule for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(decompositionRule.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(decompositionRule.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in decompositionRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(decompositionRule.ClassKind.ToString()); - writer.WriteStartArray("containedCategory"u8); - - foreach(var containedCategoryItem in decompositionRule.ContainedCategory.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(containedCategoryItem); + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("containingCategory"u8); - writer.WriteStringValue(decompositionRule.ContainingCategory); - writer.WriteStartArray("definition"u8); + break; + case "maxcontained": + var allowedVersionsForMaxContained = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in decompositionRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForMaxContained.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("maxContained"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in decompositionRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNumberValue((int)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in decompositionRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "mincontained": + var allowedVersionsForMinContained = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in decompositionRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForMinContained.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("minContained"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(decompositionRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(decompositionRule.IsDeprecated); - writer.WritePropertyName("maxContained"u8); - - if(decompositionRule.MaxContained.HasValue) + if(value != null) { - writer.WriteNumberValue(decompositionRule.MaxContained.Value); + writer.WriteNumberValue((int)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("minContained"u8); - writer.WriteNumberValue(decompositionRule.MinContained); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(decompositionRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(decompositionRule.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(decompositionRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(decompositionRule.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(decompositionRule.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -453,35 +420,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) + writer.WritePropertyName("name"u8); + + if(value != null) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -489,35 +472,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "containedcategory": - if(!AllowedVersionsPerProperty["containedCategory"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("containedCategory"u8); - - if(value is IEnumerable objectListContainedCategory) + writer.WritePropertyName("shortName"u8); + + if(value != null) { - foreach(var containedCategoryItem in objectListContainedCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(containedCategoryItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + break; - case "containingcategory": - if(!AllowedVersionsPerProperty["containingCategory"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("containingCategory"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -525,269 +522,359 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the DecompositionRule"); + } + } - writer.WriteStartArray("definition"u8); + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not DecompositionRule decompositionRule) + { + throw new ArgumentException("The thing shall be a DecompositionRule", nameof(thing)); + } - if(value is IEnumerable objectListDefinition) + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DecompositionRule since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing DecompositionRule for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in decompositionRule.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(decompositionRule.ClassKind.ToString()); + writer.WriteStartArray("containedCategory"u8); + + foreach(var containedCategoryItem in decompositionRule.ContainedCategory.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(containedCategoryItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WritePropertyName("containingCategory"u8); + writer.WriteStringValue(decompositionRule.ContainingCategory); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var definitionItem in decompositionRule.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in decompositionRule.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(decompositionRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(decompositionRule.IsDeprecated); + writer.WritePropertyName("maxContained"u8); - if(value is IEnumerable objectListExcludedPerson) + if(decompositionRule.MaxContained.HasValue) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNumberValue(decompositionRule.MaxContained.Value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("minContained"u8); + writer.WriteNumberValue(decompositionRule.MinContained); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(decompositionRule.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(decompositionRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(decompositionRule.ShortName); break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing DecompositionRule for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in decompositionRule.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(decompositionRule.ClassKind.ToString()); + writer.WriteStartArray("containedCategory"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var containedCategoryItem in decompositionRule.ContainedCategory.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(containedCategoryItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WritePropertyName("containingCategory"u8); + writer.WriteStringValue(decompositionRule.ContainingCategory); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in decompositionRule.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in decompositionRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in decompositionRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in decompositionRule.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(decompositionRule.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteBooleanValue(decompositionRule.IsDeprecated); + writer.WritePropertyName("maxContained"u8); + + if(decompositionRule.MaxContained.HasValue) { - writer.WriteBooleanValue((bool)value); + writer.WriteNumberValue(decompositionRule.MaxContained.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("minContained"u8); + writer.WriteNumberValue(decompositionRule.MinContained); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(decompositionRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(decompositionRule.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(decompositionRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(decompositionRule.ShortName); break; - case "maxcontained": - if(!AllowedVersionsPerProperty["maxContained"].Contains(requestedVersion)) - { - return; - } + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DecompositionRule for Version 1.2.0"); + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("maxContained"u8); - - if(value != null) + foreach(var aliasItem in decompositionRule.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(decompositionRule.ClassKind.ToString()); + writer.WriteStartArray("containedCategory"u8); + + foreach(var containedCategoryItem in decompositionRule.ContainedCategory.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(containedCategoryItem); } - break; - case "mincontained": - if(!AllowedVersionsPerProperty["minContained"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("containingCategory"u8); + writer.WriteStringValue(decompositionRule.ContainingCategory); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in decompositionRule.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("minContained"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in decompositionRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in decompositionRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in decompositionRule.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(decompositionRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(decompositionRule.IsDeprecated); + writer.WritePropertyName("maxContained"u8); + + if(decompositionRule.MaxContained.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteNumberValue(decompositionRule.MaxContained.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("minContained"u8); + writer.WriteNumberValue(decompositionRule.MinContained); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(decompositionRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(decompositionRule.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(decompositionRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(decompositionRule.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(decompositionRule.ThingPreference); break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DecompositionRule for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("name"u8); - - if(value != null) + if(decompositionRule.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(decompositionRule.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + foreach(var aliasItem in decompositionRule.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(decompositionRule.ClassKind.ToString()); + writer.WriteStartArray("containedCategory"u8); + + foreach(var containedCategoryItem in decompositionRule.ContainedCategory.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(containedCategoryItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("containingCategory"u8); + writer.WriteStringValue(decompositionRule.ContainingCategory); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in decompositionRule.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in decompositionRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in decompositionRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in decompositionRule.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(decompositionRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(decompositionRule.IsDeprecated); + writer.WritePropertyName("maxContained"u8); + + if(decompositionRule.MaxContained.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue(decompositionRule.MaxContained.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("minContained"u8); + writer.WriteNumberValue(decompositionRule.MinContained); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(decompositionRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(decompositionRule.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(decompositionRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(decompositionRule.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(decompositionRule.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the DecompositionRule"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "containedCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "containingCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "maxContained", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "minContained", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DefinitionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DefinitionSerializer.cs index 8554d8d6..dd3899aa 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DefinitionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DefinitionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,6 +49,354 @@ namespace CDP4JsonSerializer /// public class DefinitionSerializer : BaseThingSerializer, IThingSerializer { + /// + /// Serialize a value for a property into a + /// + /// The name of the property to serialize + /// The object value to serialize + /// The + /// The that has been requested for the serialization + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + var requestedVersion = requestedDataModelVersion.ToString(3); + + switch(propertyName.ToLower()) + { + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "citation": + var allowedVersionsForCitation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCitation.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("citation"u8); + + if(value is IEnumerable objectListCitation) + { + foreach(var citationItem in objectListCitation.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(citationItem); + } + } + + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("classKind"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } + + break; + case "content": + var allowedVersionsForContent = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContent.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("content"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "example": + var allowedVersionsForExample = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExample.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("example"u8); + + if(value is IEnumerable objectListExample) + { + foreach(var exampleItem in objectListExample.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(exampleItem); + } + } + + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "languagecode": + var allowedVersionsForLanguageCode = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("languageCode"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "note": + var allowedVersionsForNote = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNote.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("note"u8); + + if(value is IEnumerable objectListNote) + { + foreach(var noteItem in objectListNote.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(noteItem); + } + } + + writer.WriteEndArray(); + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the Definition"); + } + } + /// /// Serializes a into an /// @@ -76,7 +423,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM switch(requestedDataModelVersion.ToString(3)) { case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Definition for Version 1.0.0"); + Logger.Log(LogLevel.Debug, "Serializing Definition for Version 1.0.0"); writer.WriteStartArray("citation"u8); foreach(var citationItem in definition.Citation.OrderBy(x => x, this.GuidComparer)) @@ -85,7 +432,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(definition.ClassKind.ToString()); writer.WritePropertyName("content"u8); @@ -98,7 +444,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(definition.Iid); writer.WritePropertyName("languageCode"u8); @@ -111,12 +456,11 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(definition.RevisionNumber); break; case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Definition for Version 1.1.0"); + Logger.Log(LogLevel.Debug, "Serializing Definition for Version 1.1.0"); writer.WriteStartArray("citation"u8); foreach(var citationItem in definition.Citation.OrderBy(x => x, this.GuidComparer)) @@ -125,7 +469,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(definition.ClassKind.ToString()); writer.WritePropertyName("content"u8); @@ -138,7 +481,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in definition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -147,7 +489,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in definition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -156,7 +497,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(definition.Iid); writer.WritePropertyName("languageCode"u8); @@ -171,12 +511,11 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(definition.RevisionNumber); break; case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Definition for Version 1.2.0"); + Logger.Log(LogLevel.Debug, "Serializing Definition for Version 1.2.0"); writer.WriteStartArray("citation"u8); foreach(var citationItem in definition.Citation.OrderBy(x => x, this.GuidComparer)) @@ -185,7 +524,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(definition.ClassKind.ToString()); writer.WritePropertyName("content"u8); @@ -198,7 +536,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in definition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -207,7 +544,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in definition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -216,7 +552,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(definition.Iid); writer.WritePropertyName("languageCode"u8); @@ -231,14 +566,13 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(definition.RevisionNumber); writer.WritePropertyName("thingPreference"u8); writer.WriteStringValue(definition.ThingPreference); break; case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Definition for Version 1.3.0"); + Logger.Log(LogLevel.Debug, "Serializing Definition for Version 1.3.0"); writer.WritePropertyName("actor"u8); if(definition.Actor.HasValue) @@ -258,7 +592,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(definition.ClassKind.ToString()); writer.WritePropertyName("content"u8); @@ -271,7 +604,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in definition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -280,7 +612,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in definition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -289,7 +620,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(definition.Iid); writer.WritePropertyName("languageCode"u8); @@ -304,7 +634,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(definition.RevisionNumber); writer.WritePropertyName("thingPreference"u8); @@ -316,279 +645,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteEndObject(); } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "citation": - if(!AllowedVersionsPerProperty["citation"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("citation"u8); - - if(value is IEnumerable objectListCitation) - { - foreach(var citationItem in objectListCitation.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(citationItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("content"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "example": - if(!AllowedVersionsPerProperty["example"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("example"u8); - - if(value is IEnumerable objectListExample) - { - foreach(var exampleItem in objectListExample.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(exampleItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("languageCode"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "note": - if(!AllowedVersionsPerProperty["note"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("note"u8); - - if(value is IEnumerable objectListNote) - { - foreach(var noteItem in objectListNote.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(noteItem); - } - } - - writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the Definition"); - } - } - - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "citation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "example", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "note", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DependentParameterTypeAssignmentSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DependentParameterTypeAssignmentSerializer.cs index 9242d2ad..f3f69c56 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DependentParameterTypeAssignmentSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DependentParameterTypeAssignmentSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,137 +49,6 @@ namespace CDP4JsonSerializer /// public class DependentParameterTypeAssignmentSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not DependentParameterTypeAssignment dependentParameterTypeAssignment) - { - throw new ArgumentException("The thing shall be a DependentParameterTypeAssignment", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.2.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DependentParameterTypeAssignment since Version is below 1.2.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DependentParameterTypeAssignment for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(dependentParameterTypeAssignment.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in dependentParameterTypeAssignment.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in dependentParameterTypeAssignment.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(dependentParameterTypeAssignment.Iid); - writer.WritePropertyName("measurementScale"u8); - - if(dependentParameterTypeAssignment.MeasurementScale.HasValue) - { - writer.WriteStringValue(dependentParameterTypeAssignment.MeasurementScale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(dependentParameterTypeAssignment.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(dependentParameterTypeAssignment.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(dependentParameterTypeAssignment.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(dependentParameterTypeAssignment.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DependentParameterTypeAssignment for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(dependentParameterTypeAssignment.Actor.HasValue) - { - writer.WriteStringValue(dependentParameterTypeAssignment.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(dependentParameterTypeAssignment.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in dependentParameterTypeAssignment.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in dependentParameterTypeAssignment.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(dependentParameterTypeAssignment.Iid); - writer.WritePropertyName("measurementScale"u8); - - if(dependentParameterTypeAssignment.MeasurementScale.HasValue) - { - writer.WriteStringValue(dependentParameterTypeAssignment.MeasurementScale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(dependentParameterTypeAssignment.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(dependentParameterTypeAssignment.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(dependentParameterTypeAssignment.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(dependentParameterTypeAssignment.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -188,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -196,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -214,7 +86,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -232,7 +110,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -250,7 +135,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -268,7 +160,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -286,7 +184,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "measurementscale": - if(!AllowedVersionsPerProperty["measurementScale"].Contains(requestedVersion)) + var allowedVersionsForMeasurementScale = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMeasurementScale.Contains(requestedVersion)) { return; } @@ -304,7 +208,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -322,7 +233,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + var allowedVersionsForParameterType = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterType.Contains(requestedVersion)) { return; } @@ -340,7 +257,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -358,7 +281,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -381,21 +310,131 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.2.0", "1.3.0" }}, - { "measurementScale", new []{ "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not DependentParameterTypeAssignment dependentParameterTypeAssignment) + { + throw new ArgumentException("The thing shall be a DependentParameterTypeAssignment", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.2.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DependentParameterTypeAssignment since Version is below 1.2.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DependentParameterTypeAssignment for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(dependentParameterTypeAssignment.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in dependentParameterTypeAssignment.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in dependentParameterTypeAssignment.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(dependentParameterTypeAssignment.Iid); + writer.WritePropertyName("measurementScale"u8); + + if(dependentParameterTypeAssignment.MeasurementScale.HasValue) + { + writer.WriteStringValue(dependentParameterTypeAssignment.MeasurementScale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(dependentParameterTypeAssignment.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(dependentParameterTypeAssignment.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(dependentParameterTypeAssignment.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(dependentParameterTypeAssignment.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DependentParameterTypeAssignment for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(dependentParameterTypeAssignment.Actor.HasValue) + { + writer.WriteStringValue(dependentParameterTypeAssignment.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(dependentParameterTypeAssignment.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in dependentParameterTypeAssignment.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in dependentParameterTypeAssignment.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(dependentParameterTypeAssignment.Iid); + writer.WritePropertyName("measurementScale"u8); + + if(dependentParameterTypeAssignment.MeasurementScale.HasValue) + { + writer.WriteStringValue(dependentParameterTypeAssignment.MeasurementScale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(dependentParameterTypeAssignment.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(dependentParameterTypeAssignment.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(dependentParameterTypeAssignment.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(dependentParameterTypeAssignment.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DerivedQuantityKindSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DerivedQuantityKindSerializer.cs index f44c6f3f..1df35a4f 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DerivedQuantityKindSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DerivedQuantityKindSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,437 +50,395 @@ namespace CDP4JsonSerializer public class DerivedQuantityKindSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not DerivedQuantityKind derivedQuantityKind) - { - throw new ArgumentException("The thing shall be a DerivedQuantityKind", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DerivedQuantityKind since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing DerivedQuantityKind for Version 1.0.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in derivedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + case "actor": + var allowedVersionsForActor = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + "1.3.0", + }; - foreach(var categoryItem in derivedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(derivedQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(derivedQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in derivedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in derivedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(derivedQuantityKind.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(derivedQuantityKind.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(derivedQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var possibleScaleItem in derivedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(possibleScaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(derivedQuantityKind.QuantityDimensionSymbol); - writer.WriteStartArray("quantityKindFactor"u8); + writer.WriteStartArray("alias"u8); - foreach(var quantityKindFactorItem in derivedQuantityKind.QuantityKindFactor.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteOrderedItem(quantityKindFactorItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(derivedQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(derivedQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(derivedQuantityKind.Symbol); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing DerivedQuantityKind for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in derivedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in derivedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(derivedQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(derivedQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in derivedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in derivedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "defaultscale": + var allowedVersionsForDefaultScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in derivedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefaultScale.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("defaultScale"u8); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in derivedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(derivedQuantityKind.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(derivedQuantityKind.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(derivedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(derivedQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var possibleScaleItem in derivedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(possibleScaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(derivedQuantityKind.QuantityDimensionSymbol); - writer.WriteStartArray("quantityKindFactor"u8); + writer.WriteStartArray("definition"u8); - foreach(var quantityKindFactorItem in derivedQuantityKind.QuantityKindFactor.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteOrderedItem(quantityKindFactorItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(derivedQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(derivedQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(derivedQuantityKind.Symbol); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DerivedQuantityKind for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in derivedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in derivedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(derivedQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(derivedQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in derivedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in derivedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in derivedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in derivedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(derivedQuantityKind.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(derivedQuantityKind.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(derivedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(derivedQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); - - foreach(var possibleScaleItem in derivedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(possibleScaleItem); - } - writer.WriteEndArray(); - - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(derivedQuantityKind.QuantityDimensionSymbol); - writer.WriteStartArray("quantityKindFactor"u8); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var quantityKindFactorItem in derivedQuantityKind.QuantityKindFactor.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteOrderedItem(quantityKindFactorItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(derivedQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(derivedQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(derivedQuantityKind.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(derivedQuantityKind.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DerivedQuantityKind for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(derivedQuantityKind.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(derivedQuantityKind.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in derivedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in derivedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(derivedQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(derivedQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in derivedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in derivedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in derivedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in derivedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(derivedQuantityKind.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(derivedQuantityKind.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(derivedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(derivedQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); + break; + case "possiblescale": + var allowedVersionsForPossibleScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var possibleScaleItem in derivedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForPossibleScale.Contains(requestedVersion)) { - writer.WriteStringValue(possibleScaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(derivedQuantityKind.QuantityDimensionSymbol); - writer.WriteStartArray("quantityKindFactor"u8); + writer.WriteStartArray("possibleScale"u8); - foreach(var quantityKindFactorItem in derivedQuantityKind.QuantityKindFactor.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListPossibleScale) { - writer.WriteOrderedItem(quantityKindFactorItem); + foreach(var possibleScaleItem in objectListPossibleScale.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(possibleScaleItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(derivedQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(derivedQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(derivedQuantityKind.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(derivedQuantityKind.ThingPreference); + writer.WriteEndArray(); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "quantitydimensionsymbol": + var allowedVersionsForQuantityDimensionSymbol = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForQuantityDimensionSymbol.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("quantityDimensionSymbol"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -489,53 +446,77 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "quantitykindfactor": + var allowedVersionsForQuantityKindFactor = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForQuantityKindFactor.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("quantityKindFactor"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListQuantityKindFactor) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var quantityKindFactorItem in objectListQuantityKindFactor.OfType().OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteOrderedItem(quantityKindFactorItem); } } writer.WriteEndArray(); break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNumberValue((int)value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -543,17 +524,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "defaultscale": - if(!AllowedVersionsPerProperty["defaultScale"].Contains(requestedVersion)) + case "symbol": + var allowedVersionsForSymbol = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { return; } - writer.WritePropertyName("defaultScale"u8); + writer.WritePropertyName("symbol"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -561,307 +550,411 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the DerivedQuantityKind"); + } + } - writer.WriteStartArray("excludedPerson"u8); + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not DerivedQuantityKind derivedQuantityKind) + { + throw new ArgumentException("The thing shall be a DerivedQuantityKind", nameof(thing)); + } - if(value is IEnumerable objectListExcludedPerson) + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DerivedQuantityKind since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing DerivedQuantityKind for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in derivedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in derivedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(derivedQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(derivedQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var definitionItem in derivedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in derivedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteStringValue(derivedQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(derivedQuantityKind.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(derivedQuantityKind.Name); + writer.WriteStartArray("possibleScale"u8); + + foreach(var possibleScaleItem in derivedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(possibleScaleItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(derivedQuantityKind.QuantityDimensionSymbol); + writer.WriteStartArray("quantityKindFactor"u8); + + foreach(var quantityKindFactorItem in derivedQuantityKind.QuantityKindFactor.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(quantityKindFactorItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(derivedQuantityKind.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(derivedQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(derivedQuantityKind.Symbol); break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) - { - return; - } + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing DerivedQuantityKind for Version 1.1.0"); + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + foreach(var aliasItem in derivedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in derivedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(derivedQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(derivedQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in derivedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in derivedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in derivedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in derivedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(derivedQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(derivedQuantityKind.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(derivedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteStringValue(derivedQuantityKind.Name); + writer.WriteStartArray("possibleScale"u8); + + foreach(var possibleScaleItem in derivedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(possibleScaleItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(derivedQuantityKind.QuantityDimensionSymbol); + writer.WriteStartArray("quantityKindFactor"u8); + + foreach(var quantityKindFactorItem in derivedQuantityKind.QuantityKindFactor.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(quantityKindFactorItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(derivedQuantityKind.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(derivedQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(derivedQuantityKind.Symbol); break; - case "possiblescale": - if(!AllowedVersionsPerProperty["possibleScale"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DerivedQuantityKind for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in derivedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("possibleScale"u8); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListPossibleScale) + foreach(var categoryItem in derivedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var possibleScaleItem in objectListPossibleScale.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(possibleScaleItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "quantitydimensionsymbol": - if(!AllowedVersionsPerProperty["quantityDimensionSymbol"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(derivedQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(derivedQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in derivedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("quantityDimensionSymbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in derivedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in derivedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "quantitykindfactor": - if(!AllowedVersionsPerProperty["quantityKindFactor"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in derivedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WriteStartArray("quantityKindFactor"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(derivedQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(derivedQuantityKind.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(derivedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(derivedQuantityKind.Name); + writer.WriteStartArray("possibleScale"u8); - if(value is IEnumerable objectListQuantityKindFactor) + foreach(var possibleScaleItem in derivedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) { - foreach(var quantityKindFactorItem in objectListQuantityKindFactor.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(quantityKindFactorItem); - } + writer.WriteStringValue(possibleScaleItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(derivedQuantityKind.QuantityDimensionSymbol); + writer.WriteStartArray("quantityKindFactor"u8); + + foreach(var quantityKindFactorItem in derivedQuantityKind.QuantityKindFactor.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(quantityKindFactorItem); } + writer.WriteEndArray(); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(derivedQuantityKind.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(derivedQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(derivedQuantityKind.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(derivedQuantityKind.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DerivedQuantityKind for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(derivedQuantityKind.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(derivedQuantityKind.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) + foreach(var aliasItem in derivedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in derivedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(derivedQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(derivedQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in derivedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("symbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in derivedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in derivedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in derivedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(derivedQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(derivedQuantityKind.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(derivedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(derivedQuantityKind.Name); + writer.WriteStartArray("possibleScale"u8); + + foreach(var possibleScaleItem in derivedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(possibleScaleItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(derivedQuantityKind.QuantityDimensionSymbol); + writer.WriteStartArray("quantityKindFactor"u8); + + foreach(var quantityKindFactorItem in derivedQuantityKind.QuantityKindFactor.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(quantityKindFactorItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(derivedQuantityKind.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(derivedQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(derivedQuantityKind.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(derivedQuantityKind.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the DerivedQuantityKind"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "defaultScale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "possibleScale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "quantityDimensionSymbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "quantityKindFactor", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DerivedUnitSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DerivedUnitSerializer.cs index 100c6578..ecea0fca 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DerivedUnitSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DerivedUnitSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,341 +50,317 @@ namespace CDP4JsonSerializer public class DerivedUnitSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not DerivedUnit derivedUnit) - { - throw new ArgumentException("The thing shall be a DerivedUnit", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DerivedUnit since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing DerivedUnit for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in derivedUnit.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(derivedUnit.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in derivedUnit.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in derivedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(derivedUnit.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(derivedUnit.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(derivedUnit.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(derivedUnit.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(derivedUnit.ShortName); - writer.WriteStartArray("unitFactor"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var unitFactorItem in derivedUnit.UnitFactor.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteOrderedItem(unitFactorItem); + return; } - writer.WriteEndArray(); - - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing DerivedUnit for Version 1.1.0"); writer.WriteStartArray("alias"u8); - foreach(var aliasItem in derivedUnit.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(aliasItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(derivedUnit.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in derivedUnit.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in derivedUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in derivedUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in derivedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(derivedUnit.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(derivedUnit.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(derivedUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(derivedUnit.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(derivedUnit.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(derivedUnit.ShortName); - writer.WriteStartArray("unitFactor"u8); + writer.WriteStartArray("definition"u8); - foreach(var unitFactorItem in derivedUnit.UnitFactor.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteOrderedItem(unitFactorItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DerivedUnit for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in derivedUnit.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(derivedUnit.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in derivedUnit.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in derivedUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in derivedUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in derivedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(derivedUnit.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(derivedUnit.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(derivedUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(derivedUnit.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(derivedUnit.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(derivedUnit.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(derivedUnit.ThingPreference); - writer.WriteStartArray("unitFactor"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var unitFactorItem in derivedUnit.UnitFactor.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteOrderedItem(unitFactorItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DerivedUnit for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(derivedUnit.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(derivedUnit.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in derivedUnit.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(derivedUnit.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in derivedUnit.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in derivedUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in derivedUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in derivedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(derivedUnit.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(derivedUnit.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(derivedUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - writer.WriteStringValue(derivedUnit.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(derivedUnit.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(derivedUnit.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(derivedUnit.ThingPreference); - writer.WriteStartArray("unitFactor"u8); - - foreach(var unitFactorItem in derivedUnit.UnitFactor.OrderBy(x => x, this.OrderedItemComparer)) + + if(value != null) { - writer.WriteOrderedItem(unitFactorItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -393,35 +368,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) + writer.WritePropertyName("shortName"u8); + + if(value != null) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -429,248 +418,325 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "unitfactor": + var allowedVersionsForUnitFactor = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUnitFactor.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("unitFactor"u8); - if(value is IEnumerable objectListDefinition) + if(value is IEnumerable objectListUnitFactor) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var unitFactorItem in objectListUnitFactor.OfType().OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteStringValue(definitionItem); + writer.WriteOrderedItem(unitFactorItem); } } writer.WriteEndArray(); break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the DerivedUnit"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not DerivedUnit derivedUnit) + { + throw new ArgumentException("The thing shall be a DerivedUnit", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DerivedUnit since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing DerivedUnit for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in derivedUnit.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(derivedUnit.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var definitionItem in derivedUnit.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in derivedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(derivedUnit.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(derivedUnit.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(derivedUnit.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(derivedUnit.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(derivedUnit.ShortName); + writer.WriteStartArray("unitFactor"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var unitFactorItem in derivedUnit.UnitFactor.OrderBy(x => x, this.OrderedItemComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteOrderedItem(unitFactorItem); } - + writer.WriteEndArray(); break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing DerivedUnit for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in derivedUnit.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(derivedUnit.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var definitionItem in derivedUnit.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("excludedDomain"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + foreach(var excludedDomainItem in derivedUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in derivedUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in derivedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(derivedUnit.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else + writer.WriteBooleanValue(derivedUnit.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(derivedUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(derivedUnit.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(derivedUnit.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(derivedUnit.ShortName); + writer.WriteStartArray("unitFactor"u8); + + foreach(var unitFactorItem in derivedUnit.UnitFactor.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(unitFactorItem); } + writer.WriteEndArray(); break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DerivedUnit for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in derivedUnit.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(derivedUnit.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in derivedUnit.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in derivedUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in derivedUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in derivedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(derivedUnit.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(derivedUnit.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(derivedUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(derivedUnit.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(derivedUnit.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(derivedUnit.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(derivedUnit.ThingPreference); + writer.WriteStartArray("unitFactor"u8); + + foreach(var unitFactorItem in derivedUnit.UnitFactor.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(unitFactorItem); } + writer.WriteEndArray(); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DerivedUnit for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(derivedUnit.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(derivedUnit.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else + foreach(var aliasItem in derivedUnit.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(aliasItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(derivedUnit.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in derivedUnit.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in derivedUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in derivedUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "unitfactor": - if(!AllowedVersionsPerProperty["unitFactor"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in derivedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(derivedUnit.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(derivedUnit.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(derivedUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(derivedUnit.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(derivedUnit.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(derivedUnit.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(derivedUnit.ThingPreference); writer.WriteStartArray("unitFactor"u8); - if(value is IEnumerable objectListUnitFactor) + foreach(var unitFactorItem in derivedUnit.UnitFactor.OrderBy(x => x, this.OrderedItemComparer)) { - foreach(var unitFactorItem in objectListUnitFactor.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(unitFactorItem); - } + writer.WriteOrderedItem(unitFactorItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the DerivedUnit"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "unitFactor", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramCanvasSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramCanvasSerializer.cs index f63fa3c4..769a5640 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramCanvasSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramCanvasSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,206 +49,6 @@ namespace CDP4JsonSerializer /// public class DiagramCanvasSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not DiagramCanvas diagramCanvas) - { - throw new ArgumentException("The thing shall be a DiagramCanvas", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DiagramCanvas since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing DiagramCanvas for Version 1.1.0"); - writer.WriteStartArray("bounds"u8); - - foreach(var boundsItem in diagramCanvas.Bounds.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(boundsItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(diagramCanvas.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(diagramCanvas.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("diagramElement"u8); - - foreach(var diagramElementItem in diagramCanvas.DiagramElement.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(diagramElementItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in diagramCanvas.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in diagramCanvas.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(diagramCanvas.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(diagramCanvas.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(diagramCanvas.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(diagramCanvas.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DiagramCanvas for Version 1.2.0"); - writer.WriteStartArray("bounds"u8); - - foreach(var boundsItem in diagramCanvas.Bounds.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(boundsItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(diagramCanvas.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(diagramCanvas.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("diagramElement"u8); - - foreach(var diagramElementItem in diagramCanvas.DiagramElement.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(diagramElementItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in diagramCanvas.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in diagramCanvas.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(diagramCanvas.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(diagramCanvas.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(diagramCanvas.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(diagramCanvas.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(diagramCanvas.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DiagramCanvas for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(diagramCanvas.Actor.HasValue) - { - writer.WriteStringValue(diagramCanvas.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("bounds"u8); - - foreach(var boundsItem in diagramCanvas.Bounds.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(boundsItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(diagramCanvas.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(diagramCanvas.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("diagramElement"u8); - - foreach(var diagramElementItem in diagramCanvas.DiagramElement.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(diagramElementItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in diagramCanvas.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in diagramCanvas.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(diagramCanvas.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(diagramCanvas.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(diagramCanvas.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(diagramCanvas.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(diagramCanvas.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -257,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -265,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -283,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "bounds": - if(!AllowedVersionsPerProperty["bounds"].Contains(requestedVersion)) + var allowedVersionsForBounds = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForBounds.Contains(requestedVersion)) { return; } @@ -301,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -319,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -337,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "diagramelement": - if(!AllowedVersionsPerProperty["diagramElement"].Contains(requestedVersion)) + var allowedVersionsForDiagramElement = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDiagramElement.Contains(requestedVersion)) { return; } @@ -355,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -373,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -391,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -409,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -427,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -445,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -463,7 +336,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -486,23 +365,192 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "bounds", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "diagramElement", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not DiagramCanvas diagramCanvas) + { + throw new ArgumentException("The thing shall be a DiagramCanvas", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DiagramCanvas since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing DiagramCanvas for Version 1.1.0"); + writer.WriteStartArray("bounds"u8); + + foreach(var boundsItem in diagramCanvas.Bounds.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(boundsItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(diagramCanvas.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(diagramCanvas.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("diagramElement"u8); + + foreach(var diagramElementItem in diagramCanvas.DiagramElement.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(diagramElementItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in diagramCanvas.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in diagramCanvas.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(diagramCanvas.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(diagramCanvas.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(diagramCanvas.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(diagramCanvas.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DiagramCanvas for Version 1.2.0"); + writer.WriteStartArray("bounds"u8); + + foreach(var boundsItem in diagramCanvas.Bounds.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(boundsItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(diagramCanvas.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(diagramCanvas.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("diagramElement"u8); + + foreach(var diagramElementItem in diagramCanvas.DiagramElement.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(diagramElementItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in diagramCanvas.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in diagramCanvas.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(diagramCanvas.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(diagramCanvas.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(diagramCanvas.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(diagramCanvas.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(diagramCanvas.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DiagramCanvas for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(diagramCanvas.Actor.HasValue) + { + writer.WriteStringValue(diagramCanvas.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("bounds"u8); + + foreach(var boundsItem in diagramCanvas.Bounds.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(boundsItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(diagramCanvas.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(diagramCanvas.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("diagramElement"u8); + + foreach(var diagramElementItem in diagramCanvas.DiagramElement.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(diagramElementItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in diagramCanvas.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in diagramCanvas.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(diagramCanvas.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(diagramCanvas.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(diagramCanvas.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(diagramCanvas.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(diagramCanvas.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramEdgeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramEdgeSerializer.cs index bd83b509..54d41184 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramEdgeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramEdgeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,352 +50,355 @@ namespace CDP4JsonSerializer public class DiagramEdgeSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not DiagramEdge diagramEdge) - { - throw new ArgumentException("The thing shall be a DiagramEdge", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DiagramEdge since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing DiagramEdge for Version 1.1.0"); - writer.WriteStartArray("bounds"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var boundsItem in diagramEdge.Bounds.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(boundsItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(diagramEdge.ClassKind.ToString()); - writer.WritePropertyName("depictedThing"u8); - - if(diagramEdge.DepictedThing.HasValue) + if(value != null) { - writer.WriteStringValue(diagramEdge.DepictedThing.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("diagramElement"u8); + break; + case "bounds": + var allowedVersionsForBounds = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var diagramElementItem in diagramEdge.DiagramElement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForBounds.Contains(requestedVersion)) { - writer.WriteStringValue(diagramElementItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("bounds"u8); - foreach(var excludedDomainItem in diagramEdge.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListBounds) { - writer.WriteStringValue(excludedDomainItem); + foreach(var boundsItem in objectListBounds.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(boundsItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in diagramEdge.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(diagramEdge.Iid); - writer.WriteStartArray("localStyle"u8); - - foreach(var localStyleItem in diagramEdge.LocalStyle.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(localStyleItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(diagramEdge.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(diagramEdge.Name); - writer.WriteStartArray("point"u8); + break; + case "depictedthing": + var allowedVersionsForDepictedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var pointItem in diagramEdge.Point.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForDepictedThing.Contains(requestedVersion)) { - writer.WriteOrderedItem(pointItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("depictedThing"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(diagramEdge.RevisionNumber); - writer.WritePropertyName("sharedStyle"u8); - - if(diagramEdge.SharedStyle.HasValue) + if(value != null) { - writer.WriteStringValue(diagramEdge.SharedStyle.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("source"u8); - writer.WriteStringValue(diagramEdge.Source); - writer.WritePropertyName("target"u8); - writer.WriteStringValue(diagramEdge.Target); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DiagramEdge for Version 1.2.0"); - writer.WriteStartArray("bounds"u8); + case "diagramelement": + var allowedVersionsForDiagramElement = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var boundsItem in diagramEdge.Bounds.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDiagramElement.Contains(requestedVersion)) { - writer.WriteStringValue(boundsItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(diagramEdge.ClassKind.ToString()); - writer.WritePropertyName("depictedThing"u8); + writer.WriteStartArray("diagramElement"u8); - if(diagramEdge.DepictedThing.HasValue) + if(value is IEnumerable objectListDiagramElement) { - writer.WriteStringValue(diagramEdge.DepictedThing.Value); + foreach(var diagramElementItem in objectListDiagramElement.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(diagramElementItem); + } } - else + + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteNullValue(); - } - - writer.WriteStartArray("diagramElement"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var diagramElementItem in diagramEdge.DiagramElement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(diagramElementItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); - foreach(var excludedDomainItem in diagramEdge.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in diagramEdge.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(diagramEdge.Iid); - writer.WriteStartArray("localStyle"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var localStyleItem in diagramEdge.LocalStyle.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(localStyleItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(diagramEdge.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(diagramEdge.Name); - writer.WriteStartArray("point"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var pointItem in diagramEdge.Point.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteOrderedItem(pointItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(diagramEdge.RevisionNumber); - writer.WritePropertyName("sharedStyle"u8); - - if(diagramEdge.SharedStyle.HasValue) + if(value != null) { - writer.WriteStringValue(diagramEdge.SharedStyle.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("source"u8); - writer.WriteStringValue(diagramEdge.Source); - writer.WritePropertyName("target"u8); - writer.WriteStringValue(diagramEdge.Target); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(diagramEdge.ThingPreference); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DiagramEdge for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "localstyle": + var allowedVersionsForLocalStyle = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(diagramEdge.Actor.HasValue) + if(!allowedVersionsForLocalStyle.Contains(requestedVersion)) { - writer.WriteStringValue(diagramEdge.Actor.Value); + return; } - else + + writer.WriteStartArray("localStyle"u8); + + if(value is IEnumerable objectListLocalStyle) { - writer.WriteNullValue(); + foreach(var localStyleItem in objectListLocalStyle.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(localStyleItem); + } } + + writer.WriteEndArray(); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("bounds"u8); - - foreach(var boundsItem in diagramEdge.Bounds.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(boundsItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(diagramEdge.ClassKind.ToString()); - writer.WritePropertyName("depictedThing"u8); - - if(diagramEdge.DepictedThing.HasValue) + if(value != null) { - writer.WriteStringValue(diagramEdge.DepictedThing.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("diagramElement"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var diagramElementItem in diagramEdge.DiagramElement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(diagramElementItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in diagramEdge.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "point": + var allowedVersionsForPoint = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in diagramEdge.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForPoint.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(diagramEdge.Iid); - writer.WriteStartArray("localStyle"u8); + writer.WriteStartArray("point"u8); - foreach(var localStyleItem in diagramEdge.LocalStyle.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListPoint) { - writer.WriteStringValue(localStyleItem); + foreach(var pointItem in objectListPoint.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(pointItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(diagramEdge.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(diagramEdge.Name); - writer.WriteStartArray("point"u8); + writer.WriteEndArray(); + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var pointItem in diagramEdge.Point.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - writer.WriteOrderedItem(pointItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(diagramEdge.RevisionNumber); - writer.WritePropertyName("sharedStyle"u8); - - if(diagramEdge.SharedStyle.HasValue) + + if(value != null) { - writer.WriteStringValue(diagramEdge.SharedStyle.Value); + writer.WriteNumberValue((int)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("source"u8); - writer.WriteStringValue(diagramEdge.Source); - writer.WritePropertyName("target"u8); - writer.WriteStringValue(diagramEdge.Target); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(diagramEdge.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "sharedstyle": + var allowedVersionsForSharedStyle = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForSharedStyle.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("sharedStyle"u8); if(value != null) { @@ -408,35 +410,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "bounds": - if(!AllowedVersionsPerProperty["bounds"].Contains(requestedVersion)) + case "source": + var allowedVersionsForSource = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSource.Contains(requestedVersion)) { return; } - writer.WriteStartArray("bounds"u8); - - if(value is IEnumerable objectListBounds) + writer.WritePropertyName("source"u8); + + if(value != null) { - foreach(var boundsItem in objectListBounds.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(boundsItem); - } + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "target": + var allowedVersionsForTarget = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTarget.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("target"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((Guid)value); } else { @@ -444,17 +460,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "depictedthing": - if(!AllowedVersionsPerProperty["depictedThing"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("depictedThing"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -462,268 +484,318 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "diagramelement": - if(!AllowedVersionsPerProperty["diagramElement"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the DiagramEdge"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not DiagramEdge diagramEdge) + { + throw new ArgumentException("The thing shall be a DiagramEdge", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DiagramEdge since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing DiagramEdge for Version 1.1.0"); + writer.WriteStartArray("bounds"u8); + + foreach(var boundsItem in diagramEdge.Bounds.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(boundsItem); } - writer.WriteStartArray("diagramElement"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(diagramEdge.ClassKind.ToString()); + writer.WritePropertyName("depictedThing"u8); - if(value is IEnumerable objectListDiagramElement) + if(diagramEdge.DepictedThing.HasValue) { - foreach(var diagramElementItem in objectListDiagramElement.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(diagramElementItem); - } + writer.WriteStringValue(diagramEdge.DepictedThing.Value); } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("diagramElement"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var diagramElementItem in diagramEdge.DiagramElement.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(diagramElementItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in diagramEdge.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var excludedPersonItem in diagramEdge.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(excludedPersonItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(diagramEdge.Iid); + writer.WriteStartArray("localStyle"u8); + + foreach(var localStyleItem in diagramEdge.LocalStyle.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(localStyleItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(diagramEdge.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(diagramEdge.Name); + writer.WriteStartArray("point"u8); + + foreach(var pointItem in diagramEdge.Point.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteOrderedItem(pointItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(diagramEdge.RevisionNumber); + writer.WritePropertyName("sharedStyle"u8); + + if(diagramEdge.SharedStyle.HasValue) + { + writer.WriteStringValue(diagramEdge.SharedStyle.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("source"u8); + writer.WriteStringValue(diagramEdge.Source); + writer.WritePropertyName("target"u8); + writer.WriteStringValue(diagramEdge.Target); break; - case "localstyle": - if(!AllowedVersionsPerProperty["localStyle"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("localStyle"u8); + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DiagramEdge for Version 1.2.0"); + writer.WriteStartArray("bounds"u8); - if(value is IEnumerable objectListLocalStyle) + foreach(var boundsItem in diagramEdge.Bounds.OrderBy(x => x, this.GuidComparer)) { - foreach(var localStyleItem in objectListLocalStyle.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(localStyleItem); - } + writer.WriteStringValue(boundsItem); } - + writer.WriteEndArray(); - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(diagramEdge.ClassKind.ToString()); + writer.WritePropertyName("depictedThing"u8); - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + if(diagramEdge.DepictedThing.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(diagramEdge.DepictedThing.Value); } else { writer.WriteNullValue(); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("diagramElement"u8); - writer.WritePropertyName("name"u8); - - if(value != null) + foreach(var diagramElementItem in diagramEdge.DiagramElement.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(diagramElementItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in diagramEdge.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "point": - if(!AllowedVersionsPerProperty["point"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in diagramEdge.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WriteStartArray("point"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(diagramEdge.Iid); + writer.WriteStartArray("localStyle"u8); - if(value is IEnumerable objectListPoint) + foreach(var localStyleItem in diagramEdge.LocalStyle.OrderBy(x => x, this.GuidComparer)) { - foreach(var pointItem in objectListPoint.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(pointItem); - } + writer.WriteStringValue(localStyleItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(diagramEdge.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(diagramEdge.Name); + writer.WriteStartArray("point"u8); + + foreach(var pointItem in diagramEdge.Point.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(pointItem); } + writer.WriteEndArray(); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(diagramEdge.RevisionNumber); + writer.WritePropertyName("sharedStyle"u8); + + if(diagramEdge.SharedStyle.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(diagramEdge.SharedStyle.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("source"u8); + writer.WriteStringValue(diagramEdge.Source); + writer.WritePropertyName("target"u8); + writer.WriteStringValue(diagramEdge.Target); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(diagramEdge.ThingPreference); break; - case "sharedstyle": - if(!AllowedVersionsPerProperty["sharedStyle"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DiagramEdge for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("sharedStyle"u8); - - if(value != null) + if(diagramEdge.Actor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(diagramEdge.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "source": - if(!AllowedVersionsPerProperty["source"].Contains(requestedVersion)) + writer.WriteStartArray("bounds"u8); + + foreach(var boundsItem in diagramEdge.Bounds.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(boundsItem); } - writer.WritePropertyName("source"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(diagramEdge.ClassKind.ToString()); + writer.WritePropertyName("depictedThing"u8); + + if(diagramEdge.DepictedThing.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(diagramEdge.DepictedThing.Value); } else { writer.WriteNullValue(); } - break; - case "target": - if(!AllowedVersionsPerProperty["target"].Contains(requestedVersion)) + writer.WriteStartArray("diagramElement"u8); + + foreach(var diagramElementItem in diagramEdge.DiagramElement.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(diagramElementItem); } - writer.WritePropertyName("target"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in diagramEdge.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in diagramEdge.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(diagramEdge.Iid); + writer.WriteStartArray("localStyle"u8); + + foreach(var localStyleItem in diagramEdge.LocalStyle.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(localStyleItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(diagramEdge.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(diagramEdge.Name); + writer.WriteStartArray("point"u8); + + foreach(var pointItem in diagramEdge.Point.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteStringValue((string)value); + writer.WriteOrderedItem(pointItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(diagramEdge.RevisionNumber); + writer.WritePropertyName("sharedStyle"u8); + + if(diagramEdge.SharedStyle.HasValue) + { + writer.WriteStringValue(diagramEdge.SharedStyle.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("source"u8); + writer.WriteStringValue(diagramEdge.Source); + writer.WritePropertyName("target"u8); + writer.WriteStringValue(diagramEdge.Target); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(diagramEdge.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the DiagramEdge"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "bounds", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "depictedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "diagramElement", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "localStyle", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "point", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "sharedStyle", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "source", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "target", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramObjectSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramObjectSerializer.cs index 8c6f2971..246cec68 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramObjectSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DiagramObjectSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,107 +50,109 @@ namespace CDP4JsonSerializer public class DiagramObjectSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not DiagramObject diagramObject) - { - throw new ArgumentException("The thing shall be a DiagramObject", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DiagramObject since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing DiagramObject for Version 1.1.0"); - writer.WriteStartArray("bounds"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var boundsItem in diagramObject.Bounds.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(boundsItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(diagramObject.ClassKind.ToString()); - writer.WritePropertyName("depictedThing"u8); - - if(diagramObject.DepictedThing.HasValue) + if(value != null) { - writer.WriteStringValue(diagramObject.DepictedThing.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("diagramElement"u8); + break; + case "bounds": + var allowedVersionsForBounds = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var diagramElementItem in diagramObject.DiagramElement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForBounds.Contains(requestedVersion)) { - writer.WriteStringValue(diagramElementItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("documentation"u8); - writer.WriteStringValue(diagramObject.Documentation); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("bounds"u8); - foreach(var excludedDomainItem in diagramObject.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListBounds) { - writer.WriteStringValue(excludedDomainItem); + foreach(var boundsItem in objectListBounds.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(boundsItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in diagramObject.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(diagramObject.Iid); - writer.WriteStartArray("localStyle"u8); + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } - foreach(var localStyleItem in diagramObject.LocalStyle.OrderBy(x => x, this.GuidComparer)) + break; + case "depictedthing": + var allowedVersionsForDepictedThing = new List { - writer.WriteStringValue(localStyleItem); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDepictedThing.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("depictedThing"u8); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(diagramObject.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(diagramObject.Name); - writer.WritePropertyName("resolution"u8); - writer.WriteNumberValue(diagramObject.Resolution); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(diagramObject.RevisionNumber); - writer.WritePropertyName("sharedStyle"u8); - - if(diagramObject.SharedStyle.HasValue) + if(value != null) { - writer.WriteStringValue(diagramObject.SharedStyle.Value); + writer.WriteStringValue((Guid)value); } else { @@ -159,221 +160,249 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DiagramObject for Version 1.2.0"); - writer.WriteStartArray("bounds"u8); + case "diagramelement": + var allowedVersionsForDiagramElement = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var boundsItem in diagramObject.Bounds.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDiagramElement.Contains(requestedVersion)) { - writer.WriteStringValue(boundsItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("diagramElement"u8); + + if(value is IEnumerable objectListDiagramElement) + { + foreach(var diagramElementItem in objectListDiagramElement.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(diagramElementItem); + } + } - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(diagramObject.ClassKind.ToString()); - writer.WritePropertyName("depictedThing"u8); + writer.WriteEndArray(); + break; + case "documentation": + var allowedVersionsForDocumentation = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(diagramObject.DepictedThing.HasValue) + if(!allowedVersionsForDocumentation.Contains(requestedVersion)) { - writer.WriteStringValue(diagramObject.DepictedThing.Value); + return; + } + + writer.WritePropertyName("documentation"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("diagramElement"u8); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var diagramElementItem in diagramObject.DiagramElement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(diagramElementItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("documentation"u8); - writer.WriteStringValue(diagramObject.Documentation); writer.WriteStartArray("excludedDomain"u8); - foreach(var excludedDomainItem in diagramObject.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in diagramObject.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(diagramObject.Iid); - writer.WriteStartArray("localStyle"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var localStyleItem in diagramObject.LocalStyle.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(localStyleItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(diagramObject.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(diagramObject.Name); - writer.WritePropertyName("resolution"u8); - writer.WriteNumberValue(diagramObject.Resolution); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(diagramObject.RevisionNumber); - writer.WritePropertyName("sharedStyle"u8); - - if(diagramObject.SharedStyle.HasValue) + if(value != null) { - writer.WriteStringValue(diagramObject.SharedStyle.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(diagramObject.ThingPreference); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DiagramObject for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "localstyle": + var allowedVersionsForLocalStyle = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(diagramObject.Actor.HasValue) + if(!allowedVersionsForLocalStyle.Contains(requestedVersion)) { - writer.WriteStringValue(diagramObject.Actor.Value); + return; } - else + + writer.WriteStartArray("localStyle"u8); + + if(value is IEnumerable objectListLocalStyle) { - writer.WriteNullValue(); + foreach(var localStyleItem in objectListLocalStyle.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(localStyleItem); + } } + + writer.WriteEndArray(); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("bounds"u8); - - foreach(var boundsItem in diagramObject.Bounds.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(boundsItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(diagramObject.ClassKind.ToString()); - writer.WritePropertyName("depictedThing"u8); - - if(diagramObject.DepictedThing.HasValue) + if(value != null) { - writer.WriteStringValue(diagramObject.DepictedThing.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("diagramElement"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var diagramElementItem in diagramObject.DiagramElement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(diagramElementItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WritePropertyName("documentation"u8); - writer.WriteStringValue(diagramObject.Documentation); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in diagramObject.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in diagramObject.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(diagramObject.Iid); - writer.WriteStartArray("localStyle"u8); + break; + case "resolution": + var allowedVersionsForResolution = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var localStyleItem in diagramObject.LocalStyle.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForResolution.Contains(requestedVersion)) { - writer.WriteStringValue(localStyleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(diagramObject.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(diagramObject.Name); writer.WritePropertyName("resolution"u8); - writer.WriteNumberValue(diagramObject.Resolution); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(diagramObject.RevisionNumber); - writer.WritePropertyName("sharedStyle"u8); - - if(diagramObject.SharedStyle.HasValue) + + if(value != null) { - writer.WriteStringValue(diagramObject.SharedStyle.Value); + writer.WriteNumberValue((float)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(diagramObject.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -381,35 +410,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "bounds": - if(!AllowedVersionsPerProperty["bounds"].Contains(requestedVersion)) + case "sharedstyle": + var allowedVersionsForSharedStyle = new List { - return; - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("bounds"u8); - - if(value is IEnumerable objectListBounds) - { - foreach(var boundsItem in objectListBounds.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(boundsItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + if(!allowedVersionsForSharedStyle.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("sharedStyle"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((Guid)value); } else { @@ -417,17 +435,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "depictedthing": - if(!AllowedVersionsPerProperty["depictedThing"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("depictedThing"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -435,89 +459,108 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "diagramelement": - if(!AllowedVersionsPerProperty["diagramElement"].Contains(requestedVersion)) - { - return; - } + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the DiagramObject"); + } + } - writer.WriteStartArray("diagramElement"u8); + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not DiagramObject diagramObject) + { + throw new ArgumentException("The thing shall be a DiagramObject", nameof(thing)); + } - if(value is IEnumerable objectListDiagramElement) + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DiagramObject since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing DiagramObject for Version 1.1.0"); + writer.WriteStartArray("bounds"u8); + + foreach(var boundsItem in diagramObject.Bounds.OrderBy(x => x, this.GuidComparer)) { - foreach(var diagramElementItem in objectListDiagramElement.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(diagramElementItem); - } + writer.WriteStringValue(boundsItem); } - + writer.WriteEndArray(); - break; - case "documentation": - if(!AllowedVersionsPerProperty["documentation"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(diagramObject.ClassKind.ToString()); + writer.WritePropertyName("depictedThing"u8); - writer.WritePropertyName("documentation"u8); - - if(value != null) + if(diagramObject.DepictedThing.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(diagramObject.DepictedThing.Value); } else { writer.WriteNullValue(); } - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + writer.WriteStartArray("diagramElement"u8); + + foreach(var diagramElementItem in diagramObject.DiagramElement.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(diagramElementItem); } + writer.WriteEndArray(); + writer.WritePropertyName("documentation"u8); + writer.WriteStringValue(diagramObject.Documentation); writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + foreach(var excludedDomainItem in diagramObject.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var excludedPersonItem in diagramObject.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(excludedPersonItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(diagramObject.Iid); + writer.WriteStartArray("localStyle"u8); + + foreach(var localStyleItem in diagramObject.LocalStyle.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(localStyleItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(diagramObject.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(diagramObject.Name); + writer.WritePropertyName("resolution"u8); + writer.WriteNumberValue(diagramObject.Resolution); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(diagramObject.RevisionNumber); + writer.WritePropertyName("sharedStyle"u8); + + if(diagramObject.SharedStyle.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(diagramObject.SharedStyle.Value); } else { @@ -525,159 +568,185 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "localstyle": - if(!AllowedVersionsPerProperty["localStyle"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DiagramObject for Version 1.2.0"); + writer.WriteStartArray("bounds"u8); + + foreach(var boundsItem in diagramObject.Bounds.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(boundsItem); } - writer.WriteStartArray("localStyle"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(diagramObject.ClassKind.ToString()); + writer.WritePropertyName("depictedThing"u8); - if(value is IEnumerable objectListLocalStyle) + if(diagramObject.DepictedThing.HasValue) { - foreach(var localStyleItem in objectListLocalStyle.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(localStyleItem); - } + writer.WriteStringValue(diagramObject.DepictedThing.Value); } - - writer.WriteEndArray(); - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteStartArray("diagramElement"u8); + + foreach(var diagramElementItem in diagramObject.DiagramElement.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(diagramElementItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("documentation"u8); + writer.WriteStringValue(diagramObject.Documentation); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in diagramObject.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in diagramObject.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(diagramObject.Iid); + writer.WriteStartArray("localStyle"u8); + + foreach(var localStyleItem in diagramObject.LocalStyle.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(localStyleItem); } + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(diagramObject.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteStringValue(diagramObject.Name); + writer.WritePropertyName("resolution"u8); + writer.WriteNumberValue(diagramObject.Resolution); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(diagramObject.RevisionNumber); + writer.WritePropertyName("sharedStyle"u8); + + if(diagramObject.SharedStyle.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(diagramObject.SharedStyle.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(diagramObject.ThingPreference); break; - case "resolution": - if(!AllowedVersionsPerProperty["resolution"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DiagramObject for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("resolution"u8); - - if(value != null) + if(diagramObject.Actor.HasValue) { - writer.WriteNumberValue((float)value); + writer.WriteStringValue(diagramObject.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteStartArray("bounds"u8); + + foreach(var boundsItem in diagramObject.Bounds.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(boundsItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(diagramObject.ClassKind.ToString()); + writer.WritePropertyName("depictedThing"u8); + + if(diagramObject.DepictedThing.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(diagramObject.DepictedThing.Value); } else { writer.WriteNullValue(); } - break; - case "sharedstyle": - if(!AllowedVersionsPerProperty["sharedStyle"].Contains(requestedVersion)) + writer.WriteStartArray("diagramElement"u8); + + foreach(var diagramElementItem in diagramObject.DiagramElement.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(diagramElementItem); } - writer.WritePropertyName("sharedStyle"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("documentation"u8); + writer.WriteStringValue(diagramObject.Documentation); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in diagramObject.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in diagramObject.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(diagramObject.Iid); + writer.WriteStartArray("localStyle"u8); + + foreach(var localStyleItem in diagramObject.LocalStyle.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(localStyleItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(diagramObject.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(diagramObject.Name); + writer.WritePropertyName("resolution"u8); + writer.WriteNumberValue(diagramObject.Resolution); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(diagramObject.RevisionNumber); + writer.WritePropertyName("sharedStyle"u8); + + if(diagramObject.SharedStyle.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(diagramObject.SharedStyle.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(diagramObject.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the DiagramObject"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "bounds", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "depictedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "diagramElement", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "documentation", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "localStyle", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "resolution", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "sharedStyle", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DomainFileStoreSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DomainFileStoreSerializer.cs index 487b8d34..150af9e1 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DomainFileStoreSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DomainFileStoreSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,253 +49,6 @@ namespace CDP4JsonSerializer /// public class DomainFileStoreSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not DomainFileStore domainFileStore) - { - throw new ArgumentException("The thing shall be a DomainFileStore", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DomainFileStore since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing DomainFileStore for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainFileStore.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(domainFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("file"u8); - - foreach(var fileItem in domainFileStore.File.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(fileItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("folder"u8); - - foreach(var folderItem in domainFileStore.Folder.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(folderItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainFileStore.Iid); - writer.WritePropertyName("isHidden"u8); - writer.WriteBooleanValue(domainFileStore.IsHidden); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainFileStore.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(domainFileStore.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainFileStore.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing DomainFileStore for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainFileStore.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(domainFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in domainFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in domainFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("file"u8); - - foreach(var fileItem in domainFileStore.File.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(fileItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("folder"u8); - - foreach(var folderItem in domainFileStore.Folder.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(folderItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainFileStore.Iid); - writer.WritePropertyName("isHidden"u8); - writer.WriteBooleanValue(domainFileStore.IsHidden); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(domainFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainFileStore.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(domainFileStore.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainFileStore.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DomainFileStore for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainFileStore.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(domainFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in domainFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in domainFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("file"u8); - - foreach(var fileItem in domainFileStore.File.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(fileItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("folder"u8); - - foreach(var folderItem in domainFileStore.Folder.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(folderItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainFileStore.Iid); - writer.WritePropertyName("isHidden"u8); - writer.WriteBooleanValue(domainFileStore.IsHidden); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(domainFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainFileStore.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(domainFileStore.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainFileStore.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(domainFileStore.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DomainFileStore for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(domainFileStore.Actor.HasValue) - { - writer.WriteStringValue(domainFileStore.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainFileStore.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(domainFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in domainFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in domainFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("file"u8); - - foreach(var fileItem in domainFileStore.File.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(fileItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("folder"u8); - - foreach(var folderItem in domainFileStore.Folder.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(folderItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainFileStore.Iid); - writer.WritePropertyName("isHidden"u8); - writer.WriteBooleanValue(domainFileStore.IsHidden); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(domainFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainFileStore.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(domainFileStore.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainFileStore.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(domainFileStore.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -304,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -312,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -330,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -348,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -366,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -384,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -402,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "file": - if(!AllowedVersionsPerProperty["file"].Contains(requestedVersion)) + var allowedVersionsForFile = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFile.Contains(requestedVersion)) { return; } @@ -420,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "folder": - if(!AllowedVersionsPerProperty["folder"].Contains(requestedVersion)) + var allowedVersionsForFolder = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFolder.Contains(requestedVersion)) { return; } @@ -438,7 +240,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -456,7 +266,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "ishidden": - if(!AllowedVersionsPerProperty["isHidden"].Contains(requestedVersion)) + var allowedVersionsForIsHidden = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsHidden.Contains(requestedVersion)) { return; } @@ -474,7 +292,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -492,7 +317,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -510,7 +343,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -528,7 +369,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -546,7 +395,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -569,25 +424,237 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "file", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "folder", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isHidden", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not DomainFileStore domainFileStore) + { + throw new ArgumentException("The thing shall be a DomainFileStore", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DomainFileStore since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing DomainFileStore for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainFileStore.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(domainFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("file"u8); + + foreach(var fileItem in domainFileStore.File.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("folder"u8); + + foreach(var folderItem in domainFileStore.Folder.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(folderItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainFileStore.Iid); + writer.WritePropertyName("isHidden"u8); + writer.WriteBooleanValue(domainFileStore.IsHidden); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainFileStore.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(domainFileStore.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(domainFileStore.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing DomainFileStore for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainFileStore.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(domainFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in domainFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in domainFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("file"u8); + + foreach(var fileItem in domainFileStore.File.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("folder"u8); + + foreach(var folderItem in domainFileStore.Folder.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(folderItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainFileStore.Iid); + writer.WritePropertyName("isHidden"u8); + writer.WriteBooleanValue(domainFileStore.IsHidden); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(domainFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainFileStore.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(domainFileStore.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(domainFileStore.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DomainFileStore for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainFileStore.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(domainFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in domainFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in domainFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("file"u8); + + foreach(var fileItem in domainFileStore.File.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("folder"u8); + + foreach(var folderItem in domainFileStore.Folder.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(folderItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainFileStore.Iid); + writer.WritePropertyName("isHidden"u8); + writer.WriteBooleanValue(domainFileStore.IsHidden); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(domainFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainFileStore.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(domainFileStore.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(domainFileStore.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(domainFileStore.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DomainFileStore for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(domainFileStore.Actor.HasValue) + { + writer.WriteStringValue(domainFileStore.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainFileStore.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(domainFileStore.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in domainFileStore.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in domainFileStore.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("file"u8); + + foreach(var fileItem in domainFileStore.File.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("folder"u8); + + foreach(var folderItem in domainFileStore.Folder.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(folderItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainFileStore.Iid); + writer.WritePropertyName("isHidden"u8); + writer.WriteBooleanValue(domainFileStore.IsHidden); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(domainFileStore.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainFileStore.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(domainFileStore.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(domainFileStore.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(domainFileStore.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DomainOfExpertiseGroupSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DomainOfExpertiseGroupSerializer.cs index 0b6e75b6..39729d22 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DomainOfExpertiseGroupSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DomainOfExpertiseGroupSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,341 +50,343 @@ namespace CDP4JsonSerializer public class DomainOfExpertiseGroupSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not DomainOfExpertiseGroup domainOfExpertiseGroup) - { - throw new ArgumentException("The thing shall be a DomainOfExpertiseGroup", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DomainOfExpertiseGroup since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing DomainOfExpertiseGroup for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in domainOfExpertiseGroup.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in domainOfExpertiseGroup.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("domain"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var domainItem in domainOfExpertiseGroup.Domain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(domainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in domainOfExpertiseGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainOfExpertiseGroup.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(domainOfExpertiseGroup.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainOfExpertiseGroup.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainOfExpertiseGroup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ShortName); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing DomainOfExpertiseGroup for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in domainOfExpertiseGroup.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in domainOfExpertiseGroup.Definition.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("domain"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var domainItem in domainOfExpertiseGroup.Domain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(domainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("definition"u8); - foreach(var excludedDomainItem in domainOfExpertiseGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(excludedDomainItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "domain": + var allowedVersionsForDomain = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in domainOfExpertiseGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDomain.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("domain"u8); - foreach(var hyperLinkItem in domainOfExpertiseGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDomain) { - writer.WriteStringValue(hyperLinkItem); + foreach(var domainItem in objectListDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainOfExpertiseGroup.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(domainOfExpertiseGroup.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainOfExpertiseGroup.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainOfExpertiseGroup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DomainOfExpertiseGroup for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in domainOfExpertiseGroup.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in domainOfExpertiseGroup.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("domain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var domainItem in domainOfExpertiseGroup.Domain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(domainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in domainOfExpertiseGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in domainOfExpertiseGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in domainOfExpertiseGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainOfExpertiseGroup.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(domainOfExpertiseGroup.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainOfExpertiseGroup.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainOfExpertiseGroup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DomainOfExpertiseGroup for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(domainOfExpertiseGroup.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(domainOfExpertiseGroup.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in domainOfExpertiseGroup.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in domainOfExpertiseGroup.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("domain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var domainItem in domainOfExpertiseGroup.Domain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(domainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in domainOfExpertiseGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in domainOfExpertiseGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in domainOfExpertiseGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainOfExpertiseGroup.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(domainOfExpertiseGroup.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainOfExpertiseGroup.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainOfExpertiseGroup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(domainOfExpertiseGroup.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -393,35 +394,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) + writer.WritePropertyName("shortName"u8); + + if(value != null) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -429,248 +444,299 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the DomainOfExpertiseGroup"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not DomainOfExpertiseGroup domainOfExpertiseGroup) + { + throw new ArgumentException("The thing shall be a DomainOfExpertiseGroup", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DomainOfExpertiseGroup since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing DomainOfExpertiseGroup for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in domainOfExpertiseGroup.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ClassKind.ToString()); writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListDefinition) + foreach(var definitionItem in domainOfExpertiseGroup.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "domain": - if(!AllowedVersionsPerProperty["domain"].Contains(requestedVersion)) + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in domainOfExpertiseGroup.Domain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(domainItem); } - writer.WriteStartArray("domain"u8); + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListDomain) + foreach(var hyperLinkItem in domainOfExpertiseGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) { - foreach(var domainItem in objectListDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainItem); - } + writer.WriteStringValue(hyperLinkItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainOfExpertiseGroup.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(domainOfExpertiseGroup.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainOfExpertiseGroup.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(domainOfExpertiseGroup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ShortName); break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing DomainOfExpertiseGroup for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in domainOfExpertiseGroup.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var definitionItem in domainOfExpertiseGroup.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in domainOfExpertiseGroup.Domain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(domainItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var excludedDomainItem in domainOfExpertiseGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in domainOfExpertiseGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var hyperLinkItem in domainOfExpertiseGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(hyperLinkItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainOfExpertiseGroup.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(domainOfExpertiseGroup.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainOfExpertiseGroup.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(domainOfExpertiseGroup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ShortName); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DomainOfExpertiseGroup for Version 1.2.0"); + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + foreach(var aliasItem in domainOfExpertiseGroup.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(aliasItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) - { - return; - } + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else + foreach(var definitionItem in domainOfExpertiseGroup.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } + writer.WriteEndArray(); + writer.WriteStartArray("domain"u8); - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else + foreach(var domainItem in domainOfExpertiseGroup.Domain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(domainItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - writer.WritePropertyName("name"u8); - - if(value != null) + foreach(var excludedDomainItem in domainOfExpertiseGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in domainOfExpertiseGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in domainOfExpertiseGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainOfExpertiseGroup.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(domainOfExpertiseGroup.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainOfExpertiseGroup.Name); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(domainOfExpertiseGroup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DomainOfExpertiseGroup for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(domainOfExpertiseGroup.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(domainOfExpertiseGroup.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in domainOfExpertiseGroup.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in domainOfExpertiseGroup.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in domainOfExpertiseGroup.Domain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(domainItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in domainOfExpertiseGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in domainOfExpertiseGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in domainOfExpertiseGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainOfExpertiseGroup.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(domainOfExpertiseGroup.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainOfExpertiseGroup.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(domainOfExpertiseGroup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(domainOfExpertiseGroup.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the DomainOfExpertiseGroup"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "domain", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/DomainOfExpertiseSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/DomainOfExpertiseSerializer.cs index 27e14bd4..d5fe53e4 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/DomainOfExpertiseSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/DomainOfExpertiseSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,341 +50,317 @@ namespace CDP4JsonSerializer public class DomainOfExpertiseSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not DomainOfExpertise domainOfExpertise) - { - throw new ArgumentException("The thing shall be a DomainOfExpertise", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of DomainOfExpertise since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing DomainOfExpertise for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in domainOfExpertise.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in domainOfExpertise.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainOfExpertise.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in domainOfExpertise.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in domainOfExpertise.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainOfExpertise.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(domainOfExpertise.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainOfExpertise.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainOfExpertise.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(domainOfExpertise.ShortName); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing DomainOfExpertise for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in domainOfExpertise.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in domainOfExpertise.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainOfExpertise.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in domainOfExpertise.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in domainOfExpertise.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in domainOfExpertise.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in domainOfExpertise.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainOfExpertise.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(domainOfExpertise.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(domainOfExpertise.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainOfExpertise.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainOfExpertise.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(domainOfExpertise.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing DomainOfExpertise for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in domainOfExpertise.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in domainOfExpertise.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainOfExpertise.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in domainOfExpertise.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in domainOfExpertise.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in domainOfExpertise.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in domainOfExpertise.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainOfExpertise.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(domainOfExpertise.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(domainOfExpertise.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainOfExpertise.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainOfExpertise.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(domainOfExpertise.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(domainOfExpertise.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing DomainOfExpertise for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(domainOfExpertise.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(domainOfExpertise.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in domainOfExpertise.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in domainOfExpertise.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(domainOfExpertise.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in domainOfExpertise.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in domainOfExpertise.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in domainOfExpertise.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in domainOfExpertise.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(domainOfExpertise.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(domainOfExpertise.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(domainOfExpertise.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(domainOfExpertise.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(domainOfExpertise.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(domainOfExpertise.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(domainOfExpertise.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -393,53 +368,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + return; } + + writer.WritePropertyName("revisionNumber"u8); - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteNumberValue((int)value); } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + else { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -447,230 +420,323 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List { - return; - } + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + return; } + + writer.WritePropertyName("thingPreference"u8); - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) + else { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the DomainOfExpertise"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not DomainOfExpertise domainOfExpertise) + { + throw new ArgumentException("The thing shall be a DomainOfExpertise", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of DomainOfExpertise since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing DomainOfExpertise for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in domainOfExpertise.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var categoryItem in domainOfExpertise.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainOfExpertise.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in domainOfExpertise.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } + writer.WriteEndArray(); writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var hyperLinkItem in domainOfExpertise.HyperLink.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(hyperLinkItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainOfExpertise.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(domainOfExpertise.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainOfExpertise.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(domainOfExpertise.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(domainOfExpertise.ShortName); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing DomainOfExpertise for Version 1.1.0"); + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + foreach(var aliasItem in domainOfExpertise.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in domainOfExpertise.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainOfExpertise.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in domainOfExpertise.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in domainOfExpertise.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in domainOfExpertise.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in domainOfExpertise.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainOfExpertise.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(domainOfExpertise.IsDeprecated); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteStringValue(domainOfExpertise.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainOfExpertise.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(domainOfExpertise.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(domainOfExpertise.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing DomainOfExpertise for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in domainOfExpertise.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in domainOfExpertise.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainOfExpertise.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in domainOfExpertise.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in domainOfExpertise.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in domainOfExpertise.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in domainOfExpertise.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainOfExpertise.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(domainOfExpertise.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(domainOfExpertise.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainOfExpertise.Name); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(domainOfExpertise.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(domainOfExpertise.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(domainOfExpertise.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing DomainOfExpertise for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(domainOfExpertise.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(domainOfExpertise.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in domainOfExpertise.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in domainOfExpertise.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(domainOfExpertise.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in domainOfExpertise.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in domainOfExpertise.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in domainOfExpertise.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in domainOfExpertise.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(domainOfExpertise.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(domainOfExpertise.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(domainOfExpertise.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(domainOfExpertise.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(domainOfExpertise.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(domainOfExpertise.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(domainOfExpertise.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the DomainOfExpertise"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ElementDefinitionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ElementDefinitionSerializer.cs index dfb69030..79cf4552 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ElementDefinitionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ElementDefinitionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,355 +50,560 @@ namespace CDP4JsonSerializer public class ElementDefinitionSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ElementDefinition elementDefinition) - { - throw new ArgumentException("The thing shall be a ElementDefinition", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ElementDefinition since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ElementDefinition for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in elementDefinition.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in elementDefinition.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(elementDefinition.ClassKind.ToString()); - writer.WriteStartArray("containedElement"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var containedElementItem in elementDefinition.ContainedElement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(containedElementItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("alias"u8); - foreach(var definitionItem in elementDefinition.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(definitionItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in elementDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(elementDefinition.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(elementDefinition.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(elementDefinition.Owner); - writer.WriteStartArray("parameter"u8); + writer.WriteStartArray("category"u8); - foreach(var parameterItem in elementDefinition.Parameter.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(parameterItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("parameterGroup"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var parameterGroupItem in elementDefinition.ParameterGroup.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(parameterGroupItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("referencedElement"u8); - - foreach(var referencedElementItem in elementDefinition.ReferencedElement.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(referencedElementItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(elementDefinition.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(elementDefinition.ShortName); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ElementDefinition for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "containedelement": + var allowedVersionsForContainedElement = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in elementDefinition.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContainedElement.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("containedElement"u8); - foreach(var categoryItem in elementDefinition.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListContainedElement) { - writer.WriteStringValue(categoryItem); + foreach(var containedElementItem in objectListContainedElement.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(containedElementItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(elementDefinition.ClassKind.ToString()); - writer.WriteStartArray("containedElement"u8); + writer.WriteEndArray(); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var containedElementItem in elementDefinition.ContainedElement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(containedElementItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("definition"u8); - foreach(var definitionItem in elementDefinition.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(definitionItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in elementDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var excludedPersonItem in elementDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in elementDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(elementDefinition.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(elementDefinition.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(elementDefinition.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(elementDefinition.Owner); - writer.WriteStartArray("parameter"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var parameterItem in elementDefinition.Parameter.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(parameterItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("parameterGroup"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var parameterGroupItem in elementDefinition.ParameterGroup.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(parameterGroupItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("referencedElement"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var referencedElementItem in elementDefinition.ReferencedElement.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(referencedElementItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(elementDefinition.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(elementDefinition.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ElementDefinition for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in elementDefinition.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in elementDefinition.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(elementDefinition.ClassKind.ToString()); - writer.WriteStartArray("containedElement"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var containedElementItem in elementDefinition.ContainedElement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(containedElementItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("definition"u8); + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } - foreach(var definitionItem in elementDefinition.Definition.OrderBy(x => x, this.GuidComparer)) + break; + case "name": + var allowedVersionsForName = new List { - writer.WriteStringValue(definitionItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WriteStartArray("excludedDomain"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedDomainItem in elementDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + case "organizationalparticipant": + var allowedVersionsForOrganizationalParticipant = new List { - writer.WriteStringValue(excludedDomainItem); + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOrganizationalParticipant.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WriteStartArray("organizationalParticipant"u8); + + if(value is IEnumerable objectListOrganizationalParticipant) + { + foreach(var organizationalParticipantItem in objectListOrganizationalParticipant.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(organizationalParticipantItem); + } + } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "owner": + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in elementDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForOwner.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("owner"u8); - writer.WriteStartArray("hyperLink"u8); + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var hyperLinkItem in elementDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) + break; + case "parameter": + var allowedVersionsForParameter = new List { - writer.WriteStringValue(hyperLinkItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameter.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WriteStartArray("parameter"u8); + + if(value is IEnumerable objectListParameter) + { + foreach(var parameterItem in objectListParameter.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterItem); + } + } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(elementDefinition.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(elementDefinition.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(elementDefinition.Name); - writer.WriteStartArray("organizationalParticipant"u8); + writer.WriteEndArray(); + break; + case "parametergroup": + var allowedVersionsForParameterGroup = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var organizationalParticipantItem in elementDefinition.OrganizationalParticipant.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForParameterGroup.Contains(requestedVersion)) { - writer.WriteStringValue(organizationalParticipantItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("parameterGroup"u8); + + if(value is IEnumerable objectListParameterGroup) + { + foreach(var parameterGroupItem in objectListParameterGroup.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterGroupItem); + } + } - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(elementDefinition.Owner); - writer.WriteStartArray("parameter"u8); + writer.WriteEndArray(); + break; + case "referencedelement": + var allowedVersionsForReferencedElement = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var parameterItem in elementDefinition.Parameter.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForReferencedElement.Contains(requestedVersion)) { - writer.WriteStringValue(parameterItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("referencedElement"u8); + + if(value is IEnumerable objectListReferencedElement) + { + foreach(var referencedElementItem in objectListReferencedElement.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referencedElementItem); + } + } - writer.WriteStartArray("parameterGroup"u8); + writer.WriteEndArray(); + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var parameterGroupItem in elementDefinition.ParameterGroup.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - writer.WriteStringValue(parameterGroupItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); - writer.WriteStartArray("referencedElement"u8); + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var referencedElementItem in elementDefinition.ReferencedElement.OrderBy(x => x, this.GuidComparer)) + break; + case "shortname": + var allowedVersionsForShortName = new List { - writer.WriteStringValue(referencedElementItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(elementDefinition.RevisionNumber); writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(elementDefinition.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(elementDefinition.ThingPreference); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ElementDefinition for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; - if(elementDefinition.Actor.HasValue) + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { - writer.WriteStringValue(elementDefinition.Actor.Value); + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ElementDefinition"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ElementDefinition elementDefinition) + { + throw new ArgumentException("The thing shall be a ElementDefinition", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ElementDefinition since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ElementDefinition for Version 1.0.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in elementDefinition.Alias.OrderBy(x => x, this.GuidComparer)) @@ -408,7 +612,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("category"u8); foreach(var categoryItem in elementDefinition.Category.OrderBy(x => x, this.GuidComparer)) @@ -417,7 +620,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(elementDefinition.ClassKind.ToString()); writer.WriteStartArray("containedElement"u8); @@ -428,7 +630,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("definition"u8); foreach(var definitionItem in elementDefinition.Definition.OrderBy(x => x, this.GuidComparer)) @@ -437,497 +638,377 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var excludedDomainItem in elementDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + foreach(var hyperLinkItem in elementDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(hyperLinkItem); } writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(elementDefinition.Iid); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(elementDefinition.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(elementDefinition.Owner); + writer.WriteStartArray("parameter"u8); - foreach(var excludedPersonItem in elementDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + foreach(var parameterItem in elementDefinition.Parameter.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(parameterItem); } writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("parameterGroup"u8); - foreach(var hyperLinkItem in elementDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) + foreach(var parameterGroupItem in elementDefinition.ParameterGroup.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteStringValue(parameterGroupItem); } writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(elementDefinition.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(elementDefinition.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(elementDefinition.Name); - writer.WriteStartArray("organizationalParticipant"u8); + writer.WriteStartArray("referencedElement"u8); - foreach(var organizationalParticipantItem in elementDefinition.OrganizationalParticipant.OrderBy(x => x, this.GuidComparer)) + foreach(var referencedElementItem in elementDefinition.ReferencedElement.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(organizationalParticipantItem); + writer.WriteStringValue(referencedElementItem); } writer.WriteEndArray(); - - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(elementDefinition.Owner); - writer.WriteStartArray("parameter"u8); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(elementDefinition.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(elementDefinition.ShortName); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ElementDefinition for Version 1.1.0"); + writer.WriteStartArray("alias"u8); - foreach(var parameterItem in elementDefinition.Parameter.OrderBy(x => x, this.GuidComparer)) + foreach(var aliasItem in elementDefinition.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(parameterItem); + writer.WriteStringValue(aliasItem); } writer.WriteEndArray(); - - writer.WriteStartArray("parameterGroup"u8); + writer.WriteStartArray("category"u8); - foreach(var parameterGroupItem in elementDefinition.ParameterGroup.OrderBy(x => x, this.GuidComparer)) + foreach(var categoryItem in elementDefinition.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(parameterGroupItem); + writer.WriteStringValue(categoryItem); } writer.WriteEndArray(); - - writer.WriteStartArray("referencedElement"u8); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(elementDefinition.ClassKind.ToString()); + writer.WriteStartArray("containedElement"u8); - foreach(var referencedElementItem in elementDefinition.ReferencedElement.OrderBy(x => x, this.GuidComparer)) + foreach(var containedElementItem in elementDefinition.ContainedElement.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(referencedElementItem); + writer.WriteStringValue(containedElementItem); } writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(elementDefinition.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(elementDefinition.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(elementDefinition.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + writer.WriteStartArray("definition"u8); - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + foreach(var definitionItem in elementDefinition.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + foreach(var excludedDomainItem in elementDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WriteStartArray("alias"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListAlias) + foreach(var excludedPersonItem in elementDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + writer.WriteStringValue(excludedPersonItem); } - + writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in elementDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WriteStartArray("category"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(elementDefinition.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(elementDefinition.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(elementDefinition.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(elementDefinition.Owner); + writer.WriteStartArray("parameter"u8); - if(value is IEnumerable objectListCategory) + foreach(var parameterItem in elementDefinition.Parameter.OrderBy(x => x, this.GuidComparer)) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteStringValue(parameterItem); } - + writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("parameterGroup"u8); - writer.WritePropertyName("classKind"u8); - - if(value != null) + foreach(var parameterGroupItem in elementDefinition.ParameterGroup.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(parameterGroupItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("referencedElement"u8); + + foreach(var referencedElementItem in elementDefinition.ReferencedElement.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(referencedElementItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(elementDefinition.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(elementDefinition.ShortName); break; - case "containedelement": - if(!AllowedVersionsPerProperty["containedElement"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ElementDefinition for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in elementDefinition.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("containedElement"u8); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListContainedElement) + foreach(var categoryItem in elementDefinition.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var containedElementItem in objectListContainedElement.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(containedElementItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(elementDefinition.ClassKind.ToString()); + writer.WriteStartArray("containedElement"u8); + + foreach(var containedElementItem in elementDefinition.ContainedElement.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(containedElementItem); } + writer.WriteEndArray(); writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + foreach(var definitionItem in elementDefinition.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + foreach(var excludedDomainItem in elementDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + foreach(var excludedPersonItem in elementDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + foreach(var hyperLinkItem in elementDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } + writer.WriteStringValue(elementDefinition.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(elementDefinition.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(elementDefinition.Name); + writer.WriteStartArray("organizationalParticipant"u8); - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + foreach(var organizationalParticipantItem in elementDefinition.OrganizationalParticipant.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(organizationalParticipantItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } + writer.WriteEndArray(); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(elementDefinition.Owner); + writer.WriteStartArray("parameter"u8); - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + foreach(var parameterItem in elementDefinition.Parameter.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(parameterItem); } - writer.WritePropertyName("name"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } + writer.WriteEndArray(); + writer.WriteStartArray("parameterGroup"u8); - break; - case "organizationalparticipant": - if(!AllowedVersionsPerProperty["organizationalParticipant"].Contains(requestedVersion)) + foreach(var parameterGroupItem in elementDefinition.ParameterGroup.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(parameterGroupItem); } - writer.WriteStartArray("organizationalParticipant"u8); + writer.WriteEndArray(); + writer.WriteStartArray("referencedElement"u8); - if(value is IEnumerable objectListOrganizationalParticipant) + foreach(var referencedElementItem in elementDefinition.ReferencedElement.OrderBy(x => x, this.GuidComparer)) { - foreach(var organizationalParticipantItem in objectListOrganizationalParticipant.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(organizationalParticipantItem); - } + writer.WriteStringValue(referencedElementItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(elementDefinition.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(elementDefinition.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(elementDefinition.ThingPreference); break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ElementDefinition for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("owner"u8); - - if(value != null) + if(elementDefinition.Actor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(elementDefinition.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "parameter": - if(!AllowedVersionsPerProperty["parameter"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in elementDefinition.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("parameter"u8); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListParameter) + foreach(var categoryItem in elementDefinition.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var parameterItem in objectListParameter.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "parametergroup": - if(!AllowedVersionsPerProperty["parameterGroup"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(elementDefinition.ClassKind.ToString()); + writer.WriteStartArray("containedElement"u8); + + foreach(var containedElementItem in elementDefinition.ContainedElement.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(containedElementItem); } - writer.WriteStartArray("parameterGroup"u8); + writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListParameterGroup) + foreach(var definitionItem in elementDefinition.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var parameterGroupItem in objectListParameterGroup.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterGroupItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "referencedelement": - if(!AllowedVersionsPerProperty["referencedElement"].Contains(requestedVersion)) + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in elementDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WriteStartArray("referencedElement"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListReferencedElement) + foreach(var excludedPersonItem in elementDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - foreach(var referencedElementItem in objectListReferencedElement.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(referencedElementItem); - } + writer.WriteStringValue(excludedPersonItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("hyperLink"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else + foreach(var hyperLinkItem in elementDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(elementDefinition.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(elementDefinition.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(elementDefinition.Name); + writer.WriteStartArray("organizationalParticipant"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else + foreach(var organizationalParticipantItem in elementDefinition.OrganizationalParticipant.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(organizationalParticipantItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(elementDefinition.Owner); + writer.WriteStartArray("parameter"u8); + + foreach(var parameterItem in elementDefinition.Parameter.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(parameterItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("parameterGroup"u8); + + foreach(var parameterGroupItem in elementDefinition.ParameterGroup.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(parameterGroupItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("referencedElement"u8); + + foreach(var referencedElementItem in elementDefinition.ReferencedElement.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(referencedElementItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(elementDefinition.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(elementDefinition.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(elementDefinition.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ElementDefinition"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "containedElement", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "organizationalParticipant", new []{ "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameter", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterGroup", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "referencedElement", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ElementUsageSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ElementUsageSerializer.cs index b2751cf4..1653d0d9 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ElementUsageSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ElementUsageSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,425 +50,391 @@ namespace CDP4JsonSerializer public class ElementUsageSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ElementUsage elementUsage) - { - throw new ArgumentException("The thing shall be a ElementUsage", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ElementUsage since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ElementUsage for Version 1.0.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in elementUsage.Alias.OrderBy(x => x, this.GuidComparer)) + case "actor": + var allowedVersionsForActor = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + "1.3.0", + }; - foreach(var categoryItem in elementUsage.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(elementUsage.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in elementUsage.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("elementDefinition"u8); - writer.WriteStringValue(elementUsage.ElementDefinition); - writer.WriteStartArray("excludeOption"u8); - - foreach(var excludeOptionItem in elementUsage.ExcludeOption.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludeOptionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in elementUsage.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(elementUsage.Iid); - writer.WritePropertyName("interfaceEnd"u8); - writer.WriteStringValue(elementUsage.InterfaceEnd.ToString()); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(elementUsage.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(elementUsage.Owner); - writer.WriteStartArray("parameterOverride"u8); + writer.WriteStartArray("alias"u8); - foreach(var parameterOverrideItem in elementUsage.ParameterOverride.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(parameterOverrideItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(elementUsage.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(elementUsage.ShortName); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ElementUsage for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in elementUsage.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in elementUsage.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(elementUsage.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in elementUsage.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("elementDefinition"u8); - writer.WriteStringValue(elementUsage.ElementDefinition); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in elementUsage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in elementUsage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludeOption"u8); + writer.WriteStartArray("definition"u8); - foreach(var excludeOptionItem in elementUsage.ExcludeOption.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(excludeOptionItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "elementdefinition": + var allowedVersionsForElementDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in elementUsage.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForElementDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("elementDefinition"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(elementUsage.Iid); - writer.WritePropertyName("interfaceEnd"u8); - writer.WriteStringValue(elementUsage.InterfaceEnd.ToString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(elementUsage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(elementUsage.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(elementUsage.Owner); - writer.WriteStartArray("parameterOverride"u8); - - foreach(var parameterOverrideItem in elementUsage.ParameterOverride.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(parameterOverrideItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(elementUsage.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(elementUsage.ShortName); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ElementUsage for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in elementUsage.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in elementUsage.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(elementUsage.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in elementUsage.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("elementDefinition"u8); - writer.WriteStringValue(elementUsage.ElementDefinition); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in elementUsage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludeoption": + var allowedVersionsForExcludeOption = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in elementUsage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludeOption.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludeOption"u8); - foreach(var excludeOptionItem in elementUsage.ExcludeOption.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludeOption) { - writer.WriteStringValue(excludeOptionItem); + foreach(var excludeOptionItem in objectListExcludeOption.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludeOptionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in elementUsage.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(elementUsage.Iid); - writer.WritePropertyName("interfaceEnd"u8); - writer.WriteStringValue(elementUsage.InterfaceEnd.ToString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(elementUsage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(elementUsage.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(elementUsage.Owner); - writer.WriteStartArray("parameterOverride"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var parameterOverrideItem in elementUsage.ParameterOverride.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(parameterOverrideItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(elementUsage.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(elementUsage.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(elementUsage.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ElementUsage for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(elementUsage.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(elementUsage.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "interfaceend": + var allowedVersionsForInterfaceEnd = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in elementUsage.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForInterfaceEnd.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("interfaceEnd"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in elementUsage.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(((InterfaceEndKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(elementUsage.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in elementUsage.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("elementDefinition"u8); - writer.WriteStringValue(elementUsage.ElementDefinition); - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in elementUsage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in elementUsage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludeOption"u8); - - foreach(var excludeOptionItem in elementUsage.ExcludeOption.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludeOptionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in elementUsage.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(elementUsage.Iid); - writer.WritePropertyName("interfaceEnd"u8); - writer.WriteStringValue(elementUsage.InterfaceEnd.ToString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(elementUsage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - writer.WriteStringValue(elementUsage.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(elementUsage.Owner); - writer.WriteStartArray("parameterOverride"u8); - - foreach(var parameterOverrideItem in elementUsage.ParameterOverride.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(parameterOverrideItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(elementUsage.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(elementUsage.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(elementUsage.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "owner": + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("owner"u8); if(value != null) { @@ -481,53 +446,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "parameteroverride": + var allowedVersionsForParameterOverride = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(!allowedVersionsForParameterOverride.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("parameterOverride"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListParameterOverride) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var parameterOverrideItem in objectListParameterOverride.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(parameterOverrideItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -535,35 +498,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "elementdefinition": - if(!AllowedVersionsPerProperty["elementDefinition"].Contains(requestedVersion)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("elementDefinition"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -571,270 +524,403 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedPerson"u8); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ElementUsage"); + } + } - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ElementUsage elementUsage) + { + throw new ArgumentException("The thing shall be a ElementUsage", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ElementUsage since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ElementUsage for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in elementUsage.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "excludeoption": - if(!AllowedVersionsPerProperty["excludeOption"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in elementUsage.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WriteStartArray("excludeOption"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(elementUsage.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListExcludeOption) + foreach(var definitionItem in elementUsage.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludeOptionItem in objectListExcludeOption.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludeOptionItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WritePropertyName("elementDefinition"u8); + writer.WriteStringValue(elementUsage.ElementDefinition); + writer.WriteStartArray("excludeOption"u8); + + foreach(var excludeOptionItem in elementUsage.ExcludeOption.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludeOptionItem); } + writer.WriteEndArray(); writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var hyperLinkItem in elementUsage.HyperLink.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(hyperLinkItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(elementUsage.Iid); + writer.WritePropertyName("interfaceEnd"u8); + writer.WriteStringValue(elementUsage.InterfaceEnd.ToString()); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(elementUsage.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(elementUsage.Owner); + writer.WriteStartArray("parameterOverride"u8); + + foreach(var parameterOverrideItem in elementUsage.ParameterOverride.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(parameterOverrideItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(elementUsage.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(elementUsage.ShortName); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ElementUsage for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in elementUsage.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in elementUsage.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "interfaceend": - if(!AllowedVersionsPerProperty["interfaceEnd"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(elementUsage.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in elementUsage.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("interfaceEnd"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("elementDefinition"u8); + writer.WriteStringValue(elementUsage.ElementDefinition); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in elementUsage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((InterfaceEndKind)value).ToString()); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in elementUsage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludeOption"u8); + + foreach(var excludeOptionItem in elementUsage.ExcludeOption.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludeOptionItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in elementUsage.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(elementUsage.Iid); + writer.WritePropertyName("interfaceEnd"u8); + writer.WriteStringValue(elementUsage.InterfaceEnd.ToString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(elementUsage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(elementUsage.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(elementUsage.Owner); + writer.WriteStartArray("parameterOverride"u8); + + foreach(var parameterOverrideItem in elementUsage.ParameterOverride.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(parameterOverrideItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(elementUsage.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(elementUsage.ShortName); break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ElementUsage for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in elementUsage.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in elementUsage.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(elementUsage.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in elementUsage.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("elementDefinition"u8); + writer.WriteStringValue(elementUsage.ElementDefinition); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in elementUsage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("owner"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in elementUsage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludeOption"u8); + + foreach(var excludeOptionItem in elementUsage.ExcludeOption.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludeOptionItem); } - break; - case "parameteroverride": - if(!AllowedVersionsPerProperty["parameterOverride"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in elementUsage.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(elementUsage.Iid); + writer.WritePropertyName("interfaceEnd"u8); + writer.WriteStringValue(elementUsage.InterfaceEnd.ToString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(elementUsage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(elementUsage.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(elementUsage.Owner); writer.WriteStartArray("parameterOverride"u8); - if(value is IEnumerable objectListParameterOverride) + foreach(var parameterOverrideItem in elementUsage.ParameterOverride.OrderBy(x => x, this.GuidComparer)) { - foreach(var parameterOverrideItem in objectListParameterOverride.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterOverrideItem); - } + writer.WriteStringValue(parameterOverrideItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(elementUsage.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(elementUsage.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(elementUsage.ThingPreference); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ElementUsage for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(elementUsage.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(elementUsage.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in elementUsage.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in elementUsage.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(elementUsage.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in elementUsage.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("elementDefinition"u8); + writer.WriteStringValue(elementUsage.ElementDefinition); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in elementUsage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in elementUsage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludeOption"u8); + + foreach(var excludeOptionItem in elementUsage.ExcludeOption.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludeOptionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in elementUsage.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(elementUsage.Iid); + writer.WritePropertyName("interfaceEnd"u8); + writer.WriteStringValue(elementUsage.InterfaceEnd.ToString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(elementUsage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(elementUsage.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(elementUsage.Owner); + writer.WriteStartArray("parameterOverride"u8); + + foreach(var parameterOverrideItem in elementUsage.ParameterOverride.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterOverrideItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(elementUsage.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(elementUsage.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(elementUsage.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ElementUsage"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "elementDefinition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludeOption", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "interfaceEnd", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterOverride", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/EmailAddressSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/EmailAddressSerializer.cs index 917f19f7..806e68b7 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/EmailAddressSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/EmailAddressSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,165 +49,6 @@ namespace CDP4JsonSerializer /// public class EmailAddressSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not EmailAddress emailAddress) - { - throw new ArgumentException("The thing shall be a EmailAddress", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of EmailAddress since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing EmailAddress for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(emailAddress.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(emailAddress.Iid); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(emailAddress.RevisionNumber); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(emailAddress.Value); - writer.WritePropertyName("vcardType"u8); - writer.WriteStringValue(emailAddress.VcardType.ToString()); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing EmailAddress for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(emailAddress.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in emailAddress.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in emailAddress.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(emailAddress.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(emailAddress.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(emailAddress.RevisionNumber); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(emailAddress.Value); - writer.WritePropertyName("vcardType"u8); - writer.WriteStringValue(emailAddress.VcardType.ToString()); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing EmailAddress for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(emailAddress.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in emailAddress.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in emailAddress.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(emailAddress.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(emailAddress.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(emailAddress.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(emailAddress.ThingPreference); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(emailAddress.Value); - writer.WritePropertyName("vcardType"u8); - writer.WriteStringValue(emailAddress.VcardType.ToString()); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing EmailAddress for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(emailAddress.Actor.HasValue) - { - writer.WriteStringValue(emailAddress.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(emailAddress.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in emailAddress.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in emailAddress.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(emailAddress.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(emailAddress.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(emailAddress.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(emailAddress.ThingPreference); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(emailAddress.Value); - writer.WritePropertyName("vcardType"u8); - writer.WriteStringValue(emailAddress.VcardType.ToString()); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -216,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -224,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -242,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -260,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -278,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -296,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -314,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -332,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -350,7 +239,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -368,7 +263,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "value": - if(!AllowedVersionsPerProperty["value"].Contains(requestedVersion)) + var allowedVersionsForValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValue.Contains(requestedVersion)) { return; } @@ -386,7 +289,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "vcardtype": - if(!AllowedVersionsPerProperty["vcardType"].Contains(requestedVersion)) + var allowedVersionsForVcardType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForVcardType.Contains(requestedVersion)) { return; } @@ -409,21 +320,157 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "value", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "vcardType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not EmailAddress emailAddress) + { + throw new ArgumentException("The thing shall be a EmailAddress", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of EmailAddress since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing EmailAddress for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(emailAddress.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(emailAddress.Iid); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(emailAddress.RevisionNumber); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(emailAddress.Value); + writer.WritePropertyName("vcardType"u8); + writer.WriteStringValue(emailAddress.VcardType.ToString()); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing EmailAddress for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(emailAddress.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in emailAddress.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in emailAddress.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(emailAddress.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(emailAddress.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(emailAddress.RevisionNumber); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(emailAddress.Value); + writer.WritePropertyName("vcardType"u8); + writer.WriteStringValue(emailAddress.VcardType.ToString()); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing EmailAddress for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(emailAddress.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in emailAddress.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in emailAddress.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(emailAddress.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(emailAddress.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(emailAddress.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(emailAddress.ThingPreference); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(emailAddress.Value); + writer.WritePropertyName("vcardType"u8); + writer.WriteStringValue(emailAddress.VcardType.ToString()); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing EmailAddress for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(emailAddress.Actor.HasValue) + { + writer.WriteStringValue(emailAddress.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(emailAddress.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in emailAddress.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in emailAddress.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(emailAddress.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(emailAddress.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(emailAddress.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(emailAddress.ThingPreference); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(emailAddress.Value); + writer.WritePropertyName("vcardType"u8); + writer.WriteStringValue(emailAddress.VcardType.ToString()); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelDataDiscussionItemSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelDataDiscussionItemSerializer.cs index 86eb793b..b2c6ba21 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelDataDiscussionItemSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelDataDiscussionItemSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,197 +49,6 @@ namespace CDP4JsonSerializer /// public class EngineeringModelDataDiscussionItemSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not EngineeringModelDataDiscussionItem engineeringModelDataDiscussionItem) - { - throw new ArgumentException("The thing shall be a EngineeringModelDataDiscussionItem", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of EngineeringModelDataDiscussionItem since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModelDataDiscussionItem for Version 1.1.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in engineeringModelDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in engineeringModelDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("replyTo"u8); - - if(engineeringModelDataDiscussionItem.ReplyTo.HasValue) - { - writer.WriteStringValue(engineeringModelDataDiscussionItem.ReplyTo.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModelDataDiscussionItem.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModelDataDiscussionItem for Version 1.2.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in engineeringModelDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in engineeringModelDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("replyTo"u8); - - if(engineeringModelDataDiscussionItem.ReplyTo.HasValue) - { - writer.WriteStringValue(engineeringModelDataDiscussionItem.ReplyTo.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModelDataDiscussionItem.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModelDataDiscussionItem for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(engineeringModelDataDiscussionItem.Actor.HasValue) - { - writer.WriteStringValue(engineeringModelDataDiscussionItem.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in engineeringModelDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in engineeringModelDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("replyTo"u8); - - if(engineeringModelDataDiscussionItem.ReplyTo.HasValue) - { - writer.WriteStringValue(engineeringModelDataDiscussionItem.ReplyTo.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModelDataDiscussionItem.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(engineeringModelDataDiscussionItem.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -248,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -256,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -274,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { return; } @@ -292,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -310,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContent.Contains(requestedVersion)) { return; } @@ -328,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -346,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -364,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -382,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -400,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + var allowedVersionsForLanguageCode = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } @@ -418,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -436,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "replyto": - if(!AllowedVersionsPerProperty["replyTo"].Contains(requestedVersion)) + var allowedVersionsForReplyTo = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReplyTo.Contains(requestedVersion)) { return; } @@ -454,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -472,7 +361,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -495,24 +390,189 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "replyTo", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not EngineeringModelDataDiscussionItem engineeringModelDataDiscussionItem) + { + throw new ArgumentException("The thing shall be a EngineeringModelDataDiscussionItem", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of EngineeringModelDataDiscussionItem since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModelDataDiscussionItem for Version 1.1.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in engineeringModelDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModelDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("replyTo"u8); + + if(engineeringModelDataDiscussionItem.ReplyTo.HasValue) + { + writer.WriteStringValue(engineeringModelDataDiscussionItem.ReplyTo.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModelDataDiscussionItem.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModelDataDiscussionItem for Version 1.2.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in engineeringModelDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModelDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("replyTo"u8); + + if(engineeringModelDataDiscussionItem.ReplyTo.HasValue) + { + writer.WriteStringValue(engineeringModelDataDiscussionItem.ReplyTo.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModelDataDiscussionItem.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModelDataDiscussionItem for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(engineeringModelDataDiscussionItem.Actor.HasValue) + { + writer.WriteStringValue(engineeringModelDataDiscussionItem.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("author"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in engineeringModelDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModelDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("replyTo"u8); + + if(engineeringModelDataDiscussionItem.ReplyTo.HasValue) + { + writer.WriteStringValue(engineeringModelDataDiscussionItem.ReplyTo.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModelDataDiscussionItem.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(engineeringModelDataDiscussionItem.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelDataNoteSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelDataNoteSerializer.cs index fc7c747e..58c90055 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelDataNoteSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelDataNoteSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,251 +49,6 @@ namespace CDP4JsonSerializer /// public class EngineeringModelDataNoteSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not EngineeringModelDataNote engineeringModelDataNote) - { - throw new ArgumentException("The thing shall be a EngineeringModelDataNote", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of EngineeringModelDataNote since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModelDataNote for Version 1.1.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(engineeringModelDataNote.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModelDataNote.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(engineeringModelDataNote.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(engineeringModelDataNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in engineeringModelDataNote.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in engineeringModelDataNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in engineeringModelDataNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModelDataNote.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(engineeringModelDataNote.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModelDataNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(engineeringModelDataNote.PrimaryAnnotatedThing.HasValue) - { - writer.WriteStringValue(engineeringModelDataNote.PrimaryAnnotatedThing.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in engineeringModelDataNote.RelatedThing.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModelDataNote.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModelDataNote for Version 1.2.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(engineeringModelDataNote.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModelDataNote.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(engineeringModelDataNote.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(engineeringModelDataNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in engineeringModelDataNote.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in engineeringModelDataNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in engineeringModelDataNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModelDataNote.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(engineeringModelDataNote.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModelDataNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(engineeringModelDataNote.PrimaryAnnotatedThing.HasValue) - { - writer.WriteStringValue(engineeringModelDataNote.PrimaryAnnotatedThing.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in engineeringModelDataNote.RelatedThing.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModelDataNote.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(engineeringModelDataNote.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModelDataNote for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(engineeringModelDataNote.Actor.HasValue) - { - writer.WriteStringValue(engineeringModelDataNote.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(engineeringModelDataNote.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModelDataNote.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(engineeringModelDataNote.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(engineeringModelDataNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in engineeringModelDataNote.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in engineeringModelDataNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in engineeringModelDataNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModelDataNote.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(engineeringModelDataNote.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModelDataNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(engineeringModelDataNote.PrimaryAnnotatedThing.HasValue) - { - writer.WriteStringValue(engineeringModelDataNote.PrimaryAnnotatedThing.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in engineeringModelDataNote.RelatedThing.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModelDataNote.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(engineeringModelDataNote.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -302,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -310,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -328,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { return; } @@ -346,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -364,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContent.Contains(requestedVersion)) { return; } @@ -382,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -400,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "discussion": - if(!AllowedVersionsPerProperty["discussion"].Contains(requestedVersion)) + var allowedVersionsForDiscussion = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDiscussion.Contains(requestedVersion)) { return; } @@ -418,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -436,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -454,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -472,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + var allowedVersionsForLanguageCode = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } @@ -490,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -508,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "primaryannotatedthing": - if(!AllowedVersionsPerProperty["primaryAnnotatedThing"].Contains(requestedVersion)) + var allowedVersionsForPrimaryAnnotatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPrimaryAnnotatedThing.Contains(requestedVersion)) { return; } @@ -526,7 +361,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "relatedthing": - if(!AllowedVersionsPerProperty["relatedThing"].Contains(requestedVersion)) + var allowedVersionsForRelatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRelatedThing.Contains(requestedVersion)) { return; } @@ -544,7 +386,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -562,7 +411,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -585,26 +440,237 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "discussion", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "primaryAnnotatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "relatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not EngineeringModelDataNote engineeringModelDataNote) + { + throw new ArgumentException("The thing shall be a EngineeringModelDataNote", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of EngineeringModelDataNote since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModelDataNote for Version 1.1.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(engineeringModelDataNote.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModelDataNote.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(engineeringModelDataNote.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(engineeringModelDataNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in engineeringModelDataNote.Discussion.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in engineeringModelDataNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModelDataNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModelDataNote.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(engineeringModelDataNote.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(engineeringModelDataNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(engineeringModelDataNote.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(engineeringModelDataNote.PrimaryAnnotatedThing.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in engineeringModelDataNote.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModelDataNote.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModelDataNote for Version 1.2.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(engineeringModelDataNote.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModelDataNote.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(engineeringModelDataNote.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(engineeringModelDataNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in engineeringModelDataNote.Discussion.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in engineeringModelDataNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModelDataNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModelDataNote.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(engineeringModelDataNote.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(engineeringModelDataNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(engineeringModelDataNote.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(engineeringModelDataNote.PrimaryAnnotatedThing.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in engineeringModelDataNote.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModelDataNote.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(engineeringModelDataNote.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModelDataNote for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(engineeringModelDataNote.Actor.HasValue) + { + writer.WriteStringValue(engineeringModelDataNote.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("author"u8); + writer.WriteStringValue(engineeringModelDataNote.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModelDataNote.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(engineeringModelDataNote.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(engineeringModelDataNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in engineeringModelDataNote.Discussion.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in engineeringModelDataNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModelDataNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModelDataNote.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(engineeringModelDataNote.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(engineeringModelDataNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(engineeringModelDataNote.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(engineeringModelDataNote.PrimaryAnnotatedThing.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in engineeringModelDataNote.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModelDataNote.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(engineeringModelDataNote.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelSerializer.cs index 307e4123..e1215330 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,378 +50,366 @@ namespace CDP4JsonSerializer public class EngineeringModelSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not EngineeringModel engineeringModel) - { - throw new ArgumentException("The thing shall be a EngineeringModel", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of EngineeringModel since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModel for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModel.ClassKind.ToString()); - writer.WriteStartArray("commonFileStore"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var commonFileStoreItem in engineeringModel.CommonFileStore.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(commonFileStoreItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("engineeringModelSetup"u8); - writer.WriteStringValue(engineeringModel.EngineeringModelSetup); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModel.Iid); - writer.WriteStartArray("iteration"u8); - - foreach(var iterationItem in engineeringModel.Iteration.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(iterationItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("lastModifiedOn"u8); - writer.WriteStringValue(engineeringModel.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("logEntry"u8); - - foreach(var logEntryItem in engineeringModel.LogEntry.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(logEntryItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModel.RevisionNumber); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModel for Version 1.1.0"); - writer.WriteStartArray("book"u8); + case "book": + var allowedVersionsForBook = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var bookItem in engineeringModel.Book.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForBook.Contains(requestedVersion)) { - writer.WriteOrderedItem(bookItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModel.ClassKind.ToString()); - writer.WriteStartArray("commonFileStore"u8); + writer.WriteStartArray("book"u8); - foreach(var commonFileStoreItem in engineeringModel.CommonFileStore.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListBook) { - writer.WriteStringValue(commonFileStoreItem); + foreach(var bookItem in objectListBook.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(bookItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("engineeringModelSetup"u8); - writer.WriteStringValue(engineeringModel.EngineeringModelSetup); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in engineeringModel.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in engineeringModel.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("genericNote"u8); - - foreach(var genericNoteItem in engineeringModel.GenericNote.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(genericNoteItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModel.Iid); - writer.WriteStartArray("iteration"u8); + break; + case "commonfilestore": + var allowedVersionsForCommonFileStore = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var iterationItem in engineeringModel.Iteration.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCommonFileStore.Contains(requestedVersion)) { - writer.WriteStringValue(iterationItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("lastModifiedOn"u8); - writer.WriteStringValue(engineeringModel.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("logEntry"u8); + writer.WriteStartArray("commonFileStore"u8); - foreach(var logEntryItem in engineeringModel.LogEntry.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCommonFileStore) { - writer.WriteStringValue(logEntryItem); + foreach(var commonFileStoreItem in objectListCommonFileStore.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(commonFileStoreItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("modellingAnnotation"u8); + writer.WriteEndArray(); + break; + case "engineeringmodelsetup": + var allowedVersionsForEngineeringModelSetup = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var modellingAnnotationItem in engineeringModel.ModellingAnnotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForEngineeringModelSetup.Contains(requestedVersion)) { - writer.WriteStringValue(modellingAnnotationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("engineeringModelSetup"u8); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModel.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModel.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModel for Version 1.2.0"); - writer.WriteStartArray("book"u8); - - foreach(var bookItem in engineeringModel.Book.OrderBy(x => x, this.OrderedItemComparer)) + if(value != null) { - writer.WriteOrderedItem(bookItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModel.ClassKind.ToString()); - writer.WriteStartArray("commonFileStore"u8); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var commonFileStoreItem in engineeringModel.CommonFileStore.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(commonFileStoreItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("engineeringModelSetup"u8); - writer.WriteStringValue(engineeringModel.EngineeringModelSetup); writer.WriteStartArray("excludedDomain"u8); - foreach(var excludedDomainItem in engineeringModel.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in engineeringModel.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("genericNote"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var genericNoteItem in engineeringModel.GenericNote.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(genericNoteItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModel.Iid); - writer.WriteStartArray("iteration"u8); + writer.WriteEndArray(); + break; + case "genericnote": + var allowedVersionsForGenericNote = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var iterationItem in engineeringModel.Iteration.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForGenericNote.Contains(requestedVersion)) { - writer.WriteStringValue(iterationItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("lastModifiedOn"u8); - writer.WriteStringValue(engineeringModel.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("logEntry"u8); + writer.WriteStartArray("genericNote"u8); - foreach(var logEntryItem in engineeringModel.LogEntry.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListGenericNote) { - writer.WriteStringValue(logEntryItem); + foreach(var genericNoteItem in objectListGenericNote.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(genericNoteItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("modellingAnnotation"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var modellingAnnotationItem in engineeringModel.ModellingAnnotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(modellingAnnotationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModel.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModel.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(engineeringModel.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModel for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(engineeringModel.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(engineeringModel.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("book"u8); + break; + case "iteration": + var allowedVersionsForIteration = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var bookItem in engineeringModel.Book.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForIteration.Contains(requestedVersion)) { - writer.WriteOrderedItem(bookItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModel.ClassKind.ToString()); - writer.WriteStartArray("commonFileStore"u8); + writer.WriteStartArray("iteration"u8); - foreach(var commonFileStoreItem in engineeringModel.CommonFileStore.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListIteration) { - writer.WriteStringValue(commonFileStoreItem); + foreach(var iterationItem in objectListIteration.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(iterationItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("engineeringModelSetup"u8); - writer.WriteStringValue(engineeringModel.EngineeringModelSetup); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "lastmodifiedon": + var allowedVersionsForLastModifiedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in engineeringModel.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForLastModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("lastModifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in engineeringModel.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("genericNote"u8); + break; + case "logentry": + var allowedVersionsForLogEntry = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var genericNoteItem in engineeringModel.GenericNote.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForLogEntry.Contains(requestedVersion)) { - writer.WriteStringValue(genericNoteItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModel.Iid); - writer.WriteStartArray("iteration"u8); + writer.WriteStartArray("logEntry"u8); - foreach(var iterationItem in engineeringModel.Iteration.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListLogEntry) { - writer.WriteStringValue(iterationItem); + foreach(var logEntryItem in objectListLogEntry.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(logEntryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("lastModifiedOn"u8); - writer.WriteStringValue(engineeringModel.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("logEntry"u8); + writer.WriteEndArray(); + break; + case "modellingannotation": + var allowedVersionsForModellingAnnotation = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var logEntryItem in engineeringModel.LogEntry.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModellingAnnotation.Contains(requestedVersion)) { - writer.WriteStringValue(logEntryItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("modellingAnnotation"u8); - foreach(var modellingAnnotationItem in engineeringModel.ModellingAnnotation.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListModellingAnnotation) { - writer.WriteStringValue(modellingAnnotationItem); + foreach(var modellingAnnotationItem in objectListModellingAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(modellingAnnotationItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModel.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModel.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(engineeringModel.ThingPreference); + writer.WriteEndArray(); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -430,35 +417,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "book": - if(!AllowedVersionsPerProperty["book"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("book"u8); - - if(value is IEnumerable objectListBook) - { - foreach(var bookItem in objectListBook.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(bookItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -466,35 +443,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "commonfilestore": - if(!AllowedVersionsPerProperty["commonFileStore"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List { - return; - } - - writer.WriteStartArray("commonFileStore"u8); + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListCommonFileStore) - { - foreach(var commonFileStoreItem in objectListCommonFileStore.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(commonFileStoreItem); - } - } - - writer.WriteEndArray(); - break; - case "engineeringmodelsetup": - if(!AllowedVersionsPerProperty["engineeringModelSetup"].Contains(requestedVersion)) + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("engineeringModelSetup"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -502,231 +467,331 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the EngineeringModel"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not EngineeringModel engineeringModel) + { + throw new ArgumentException("The thing shall be a EngineeringModel", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of EngineeringModel since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModel for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModel.ClassKind.ToString()); + writer.WriteStartArray("commonFileStore"u8); + + foreach(var commonFileStoreItem in engineeringModel.CommonFileStore.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(commonFileStoreItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WritePropertyName("engineeringModelSetup"u8); + writer.WriteStringValue(engineeringModel.EngineeringModelSetup); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModel.Iid); + writer.WriteStartArray("iteration"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var iterationItem in engineeringModel.Iteration.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(iterationItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WritePropertyName("lastModifiedOn"u8); + writer.WriteStringValue(engineeringModel.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("logEntry"u8); + + foreach(var logEntryItem in engineeringModel.LogEntry.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(logEntryItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModel.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModel for Version 1.1.0"); + writer.WriteStartArray("book"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var bookItem in engineeringModel.Book.OrderBy(x => x, this.OrderedItemComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteOrderedItem(bookItem); } - + writer.WriteEndArray(); - break; - case "genericnote": - if(!AllowedVersionsPerProperty["genericNote"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModel.ClassKind.ToString()); + writer.WriteStartArray("commonFileStore"u8); + + foreach(var commonFileStoreItem in engineeringModel.CommonFileStore.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(commonFileStoreItem); } - writer.WriteStartArray("genericNote"u8); + writer.WriteEndArray(); + writer.WritePropertyName("engineeringModelSetup"u8); + writer.WriteStringValue(engineeringModel.EngineeringModelSetup); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListGenericNote) + foreach(var excludedDomainItem in engineeringModel.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var genericNoteItem in objectListGenericNote.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(genericNoteItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModel.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("genericNote"u8); + + foreach(var genericNoteItem in engineeringModel.GenericNote.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(genericNoteItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModel.Iid); + writer.WriteStartArray("iteration"u8); + + foreach(var iterationItem in engineeringModel.Iteration.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(iterationItem); } - break; - case "iteration": - if(!AllowedVersionsPerProperty["iteration"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("lastModifiedOn"u8); + writer.WriteStringValue(engineeringModel.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("logEntry"u8); + + foreach(var logEntryItem in engineeringModel.LogEntry.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(logEntryItem); } - writer.WriteStartArray("iteration"u8); + writer.WriteEndArray(); + writer.WriteStartArray("modellingAnnotation"u8); - if(value is IEnumerable objectListIteration) + foreach(var modellingAnnotationItem in engineeringModel.ModellingAnnotation.OrderBy(x => x, this.GuidComparer)) { - foreach(var iterationItem in objectListIteration.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(iterationItem); - } + writer.WriteStringValue(modellingAnnotationItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(engineeringModel.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModel.RevisionNumber); break; - case "lastmodifiedon": - if(!AllowedVersionsPerProperty["lastModifiedOn"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModel for Version 1.2.0"); + writer.WriteStartArray("book"u8); + + foreach(var bookItem in engineeringModel.Book.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(bookItem); } - writer.WritePropertyName("lastModifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModel.ClassKind.ToString()); + writer.WriteStartArray("commonFileStore"u8); + + foreach(var commonFileStoreItem in engineeringModel.CommonFileStore.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(commonFileStoreItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("engineeringModelSetup"u8); + writer.WriteStringValue(engineeringModel.EngineeringModelSetup); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in engineeringModel.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "logentry": - if(!AllowedVersionsPerProperty["logEntry"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModel.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WriteStartArray("logEntry"u8); + writer.WriteEndArray(); + writer.WriteStartArray("genericNote"u8); - if(value is IEnumerable objectListLogEntry) + foreach(var genericNoteItem in engineeringModel.GenericNote.OrderBy(x => x, this.GuidComparer)) { - foreach(var logEntryItem in objectListLogEntry.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(logEntryItem); - } + writer.WriteStringValue(genericNoteItem); } - + writer.WriteEndArray(); - break; - case "modellingannotation": - if(!AllowedVersionsPerProperty["modellingAnnotation"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModel.Iid); + writer.WriteStartArray("iteration"u8); + + foreach(var iterationItem in engineeringModel.Iteration.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(iterationItem); } - writer.WriteStartArray("modellingAnnotation"u8); + writer.WriteEndArray(); + writer.WritePropertyName("lastModifiedOn"u8); + writer.WriteStringValue(engineeringModel.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("logEntry"u8); - if(value is IEnumerable objectListModellingAnnotation) + foreach(var logEntryItem in engineeringModel.LogEntry.OrderBy(x => x, this.GuidComparer)) { - foreach(var modellingAnnotationItem in objectListModellingAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(modellingAnnotationItem); - } + writer.WriteStringValue(logEntryItem); } - + writer.WriteEndArray(); - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteStartArray("modellingAnnotation"u8); + + foreach(var modellingAnnotationItem in engineeringModel.ModellingAnnotation.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(modellingAnnotationItem); } + writer.WriteEndArray(); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteStringValue(engineeringModel.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModel.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(engineeringModel.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModel for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(engineeringModel.Actor.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(engineeringModel.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteStartArray("book"u8); + + foreach(var bookItem in engineeringModel.Book.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(bookItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModel.ClassKind.ToString()); + writer.WriteStartArray("commonFileStore"u8); + + foreach(var commonFileStoreItem in engineeringModel.CommonFileStore.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(commonFileStoreItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("engineeringModelSetup"u8); + writer.WriteStringValue(engineeringModel.EngineeringModelSetup); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in engineeringModel.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModel.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("genericNote"u8); + + foreach(var genericNoteItem in engineeringModel.GenericNote.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(genericNoteItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModel.Iid); + writer.WriteStartArray("iteration"u8); + + foreach(var iterationItem in engineeringModel.Iteration.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(iterationItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("lastModifiedOn"u8); + writer.WriteStringValue(engineeringModel.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("logEntry"u8); + + foreach(var logEntryItem in engineeringModel.LogEntry.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(logEntryItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("modellingAnnotation"u8); + + foreach(var modellingAnnotationItem in engineeringModel.ModellingAnnotation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(modellingAnnotationItem); } + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(engineeringModel.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModel.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(engineeringModel.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the EngineeringModel"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "book", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "commonFileStore", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "engineeringModelSetup", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "genericNote", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iteration", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "lastModifiedOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "logEntry", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modellingAnnotation", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelSetupSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelSetupSerializer.cs index 7ee57ff9..a2648606 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelSetupSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/EngineeringModelSetupSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,563 +50,543 @@ namespace CDP4JsonSerializer public class EngineeringModelSetupSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not EngineeringModelSetup engineeringModelSetup) - { - throw new ArgumentException("The thing shall be a EngineeringModelSetup", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.0.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of EngineeringModelSetup since Version is below 1.0.0"); - return; - } + case "activedomain": + var allowedVersionsForActiveDomain = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartObject(); + if(!allowedVersionsForActiveDomain.Contains(requestedVersion)) + { + return; + } - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModelSetup for Version 1.0.0"); writer.WriteStartArray("activeDomain"u8); - foreach(var activeDomainItem in engineeringModelSetup.ActiveDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListActiveDomain) { - writer.WriteStringValue(activeDomainItem); + foreach(var activeDomainItem in objectListActiveDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(activeDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("alias"u8); + writer.WriteEndArray(); + break; + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in engineeringModelSetup.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModelSetup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in engineeringModelSetup.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("engineeringModelIid"u8); - writer.WriteStringValue(engineeringModelSetup.EngineeringModelIid); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in engineeringModelSetup.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModelSetup.Iid); - writer.WriteStartArray("iterationSetup"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var iterationSetupItem in engineeringModelSetup.IterationSetup.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(iterationSetupItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("kind"u8); - writer.WriteStringValue(engineeringModelSetup.Kind.ToString()); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(engineeringModelSetup.Name); - writer.WriteStartArray("participant"u8); + writer.WriteStartArray("alias"u8); - foreach(var participantItem in engineeringModelSetup.Participant.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(participantItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("requiredRdl"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var requiredRdlItem in engineeringModelSetup.RequiredRdl.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(requiredRdlItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModelSetup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(engineeringModelSetup.ShortName); - writer.WritePropertyName("sourceEngineeringModelSetupIid"u8); - - if(engineeringModelSetup.SourceEngineeringModelSetupIid.HasValue) + if(value != null) { - writer.WriteStringValue(engineeringModelSetup.SourceEngineeringModelSetupIid.Value); + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WritePropertyName("studyPhase"u8); - writer.WriteStringValue(engineeringModelSetup.StudyPhase.ToString()); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModelSetup for Version 1.1.0"); - writer.WriteStartArray("activeDomain"u8); - - foreach(var activeDomainItem in engineeringModelSetup.ActiveDomain.OrderBy(x => x, this.GuidComparer)) + case "defaultorganizationalparticipant": + var allowedVersionsForDefaultOrganizationalParticipant = new List { - writer.WriteStringValue(activeDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("alias"u8); + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in engineeringModelSetup.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefaultOrganizationalParticipant.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("defaultOrganizationalParticipant"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModelSetup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in engineeringModelSetup.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("engineeringModelIid"u8); - writer.WriteStringValue(engineeringModelSetup.EngineeringModelIid); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in engineeringModelSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in engineeringModelSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "definition": + var allowedVersionsForDefinition = new List { - writer.WriteStringValue(excludedPersonItem); - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in engineeringModelSetup.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModelSetup.Iid); - writer.WriteStartArray("iterationSetup"u8); + writer.WriteStartArray("definition"u8); - foreach(var iterationSetupItem in engineeringModelSetup.IterationSetup.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(iterationSetupItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("kind"u8); - writer.WriteStringValue(engineeringModelSetup.Kind.ToString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModelSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(engineeringModelSetup.Name); - writer.WriteStartArray("participant"u8); - - foreach(var participantItem in engineeringModelSetup.Participant.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(participantItem); - } - writer.WriteEndArray(); - - writer.WriteStartArray("requiredRdl"u8); + break; + case "engineeringmodeliid": + var allowedVersionsForEngineeringModelIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var requiredRdlItem in engineeringModelSetup.RequiredRdl.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForEngineeringModelIid.Contains(requestedVersion)) { - writer.WriteStringValue(requiredRdlItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("engineeringModelIid"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModelSetup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(engineeringModelSetup.ShortName); - writer.WritePropertyName("sourceEngineeringModelSetupIid"u8); - - if(engineeringModelSetup.SourceEngineeringModelSetupIid.HasValue) + if(value != null) { - writer.WriteStringValue(engineeringModelSetup.SourceEngineeringModelSetupIid.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("studyPhase"u8); - writer.WriteStringValue(engineeringModelSetup.StudyPhase.ToString()); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModelSetup for Version 1.2.0"); - writer.WriteStartArray("activeDomain"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var activeDomainItem in engineeringModelSetup.ActiveDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(activeDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var aliasItem in engineeringModelSetup.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(aliasItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModelSetup.ClassKind.ToString()); - writer.WritePropertyName("defaultOrganizationalParticipant"u8); - - if(engineeringModelSetup.DefaultOrganizationalParticipant.HasValue) + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List { - writer.WriteStringValue(engineeringModelSetup.DefaultOrganizationalParticipant.Value); - } - else + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteNullValue(); + return; } - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var definitionItem in engineeringModelSetup.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(definitionItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("engineeringModelIid"u8); - writer.WriteStringValue(engineeringModelSetup.EngineeringModelIid); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in engineeringModelSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var excludedPersonItem in engineeringModelSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(excludedPersonItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in engineeringModelSetup.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModelSetup.Iid); - writer.WriteStartArray("iterationSetup"u8); - - foreach(var iterationSetupItem in engineeringModelSetup.IterationSetup.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(iterationSetupItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("kind"u8); - writer.WriteStringValue(engineeringModelSetup.Kind.ToString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModelSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(engineeringModelSetup.Name); - writer.WriteStartArray("organizationalParticipant"u8); + break; + case "iterationsetup": + var allowedVersionsForIterationSetup = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var organizationalParticipantItem in engineeringModelSetup.OrganizationalParticipant.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIterationSetup.Contains(requestedVersion)) { - writer.WriteStringValue(organizationalParticipantItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("participant"u8); + writer.WriteStartArray("iterationSetup"u8); - foreach(var participantItem in engineeringModelSetup.Participant.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListIterationSetup) { - writer.WriteStringValue(participantItem); + foreach(var iterationSetupItem in objectListIterationSetup.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(iterationSetupItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("requiredRdl"u8); + writer.WriteEndArray(); + break; + case "kind": + var allowedVersionsForKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var requiredRdlItem in engineeringModelSetup.RequiredRdl.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForKind.Contains(requestedVersion)) { - writer.WriteStringValue(requiredRdlItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("kind"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModelSetup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(engineeringModelSetup.ShortName); - writer.WritePropertyName("sourceEngineeringModelSetupIid"u8); - - if(engineeringModelSetup.SourceEngineeringModelSetupIid.HasValue) + if(value != null) { - writer.WriteStringValue(engineeringModelSetup.SourceEngineeringModelSetupIid.Value); + writer.WriteStringValue(((EngineeringModelKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WritePropertyName("studyPhase"u8); - writer.WriteStringValue(engineeringModelSetup.StudyPhase.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(engineeringModelSetup.ThingPreference); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing EngineeringModelSetup for Version 1.3.0"); - writer.WriteStartArray("activeDomain"u8); + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var activeDomainItem in engineeringModelSetup.ActiveDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(activeDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WritePropertyName("actor"u8); - - if(engineeringModelSetup.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(engineeringModelSetup.Actor.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in engineeringModelSetup.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(engineeringModelSetup.ClassKind.ToString()); - writer.WritePropertyName("defaultOrganizationalParticipant"u8); - - if(engineeringModelSetup.DefaultOrganizationalParticipant.HasValue) + if(value != null) { - writer.WriteStringValue(engineeringModelSetup.DefaultOrganizationalParticipant.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("definition"u8); + break; + case "organizationalparticipant": + var allowedVersionsForOrganizationalParticipant = new List + { + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in engineeringModelSetup.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForOrganizationalParticipant.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("engineeringModelIid"u8); - writer.WriteStringValue(engineeringModelSetup.EngineeringModelIid); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("organizationalParticipant"u8); - foreach(var excludedDomainItem in engineeringModelSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListOrganizationalParticipant) { - writer.WriteStringValue(excludedDomainItem); + foreach(var organizationalParticipantItem in objectListOrganizationalParticipant.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(organizationalParticipantItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "participant": + var allowedVersionsForParticipant = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in engineeringModelSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForParticipant.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("participant"u8); - foreach(var hyperLinkItem in engineeringModelSetup.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListParticipant) { - writer.WriteStringValue(hyperLinkItem); + foreach(var participantItem in objectListParticipant.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(participantItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(engineeringModelSetup.Iid); - writer.WriteStartArray("iterationSetup"u8); + writer.WriteEndArray(); + break; + case "requiredrdl": + var allowedVersionsForRequiredRdl = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var iterationSetupItem in engineeringModelSetup.IterationSetup.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRequiredRdl.Contains(requestedVersion)) { - writer.WriteStringValue(iterationSetupItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("kind"u8); - writer.WriteStringValue(engineeringModelSetup.Kind.ToString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(engineeringModelSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(engineeringModelSetup.Name); - writer.WriteStartArray("organizationalParticipant"u8); + writer.WriteStartArray("requiredRdl"u8); - foreach(var organizationalParticipantItem in engineeringModelSetup.OrganizationalParticipant.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListRequiredRdl) { - writer.WriteStringValue(organizationalParticipantItem); + foreach(var requiredRdlItem in objectListRequiredRdl.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(requiredRdlItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("participant"u8); + writer.WriteEndArray(); + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var participantItem in engineeringModelSetup.Participant.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - writer.WriteStringValue(participantItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); - writer.WriteStartArray("requiredRdl"u8); + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var requiredRdlItem in engineeringModelSetup.RequiredRdl.OrderBy(x => x, this.GuidComparer)) + break; + case "shortname": + var allowedVersionsForShortName = new List { - writer.WriteStringValue(requiredRdlItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(engineeringModelSetup.RevisionNumber); writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(engineeringModelSetup.ShortName); - writer.WritePropertyName("sourceEngineeringModelSetupIid"u8); - - if(engineeringModelSetup.SourceEngineeringModelSetupIid.HasValue) + + if(value != null) { - writer.WriteStringValue(engineeringModelSetup.SourceEngineeringModelSetupIid.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("studyPhase"u8); - writer.WriteStringValue(engineeringModelSetup.StudyPhase.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(engineeringModelSetup.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } + case "sourceengineeringmodelsetupiid": + var allowedVersionsForSourceEngineeringModelSetupIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "activedomain": - if(!AllowedVersionsPerProperty["activeDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("activeDomain"u8); - - if(value is IEnumerable objectListActiveDomain) - { - foreach(var activeDomainItem in objectListActiveDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(activeDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForSourceEngineeringModelSetupIid.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("sourceEngineeringModelSetupIid"u8); if(value != null) { @@ -619,35 +598,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "studyphase": + var allowedVersionsForStudyPhase = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + if(!allowedVersionsForStudyPhase.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("studyPhase"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(((StudyPhaseKind)value).ToString()); } else { @@ -655,17 +624,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "defaultorganizationalparticipant": - if(!AllowedVersionsPerProperty["defaultOrganizationalParticipant"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("defaultOrganizationalParticipant"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -673,364 +648,493 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the EngineeringModelSetup"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not EngineeringModelSetup engineeringModelSetup) + { + throw new ArgumentException("The thing shall be a EngineeringModelSetup", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of EngineeringModelSetup since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModelSetup for Version 1.0.0"); + writer.WriteStartArray("activeDomain"u8); + + foreach(var activeDomainItem in engineeringModelSetup.ActiveDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(activeDomainItem); } - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + writer.WriteStartArray("alias"u8); - if(value is IEnumerable objectListDefinition) + foreach(var aliasItem in engineeringModelSetup.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "engineeringmodeliid": - if(!AllowedVersionsPerProperty["engineeringModelIid"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModelSetup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in engineeringModelSetup.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } + writer.WriteEndArray(); writer.WritePropertyName("engineeringModelIid"u8); - - if(value != null) + writer.WriteStringValue(engineeringModelSetup.EngineeringModelIid); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in engineeringModelSetup.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModelSetup.Iid); + writer.WriteStartArray("iterationSetup"u8); + + foreach(var iterationSetupItem in engineeringModelSetup.IterationSetup.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(iterationSetupItem); } - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("kind"u8); + writer.WriteStringValue(engineeringModelSetup.Kind.ToString()); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(engineeringModelSetup.Name); + writer.WriteStartArray("participant"u8); + + foreach(var participantItem in engineeringModelSetup.Participant.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(participantItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WriteStartArray("requiredRdl"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var requiredRdlItem in engineeringModelSetup.RequiredRdl.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(requiredRdlItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModelSetup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(engineeringModelSetup.ShortName); + writer.WritePropertyName("sourceEngineeringModelSetupIid"u8); + + if(engineeringModelSetup.SourceEngineeringModelSetupIid.HasValue) { - return; + writer.WriteStringValue(engineeringModelSetup.SourceEngineeringModelSetupIid.Value); + } + else + { + writer.WriteNullValue(); } - writer.WriteStartArray("excludedPerson"u8); + writer.WritePropertyName("studyPhase"u8); + writer.WriteStringValue(engineeringModelSetup.StudyPhase.ToString()); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModelSetup for Version 1.1.0"); + writer.WriteStartArray("activeDomain"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var activeDomainItem in engineeringModelSetup.ActiveDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(activeDomainItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in engineeringModelSetup.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModelSetup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var definitionItem in engineeringModelSetup.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WritePropertyName("engineeringModelIid"u8); + writer.WriteStringValue(engineeringModelSetup.EngineeringModelIid); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in engineeringModelSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModelSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in engineeringModelSetup.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } - break; - case "iterationsetup": - if(!AllowedVersionsPerProperty["iterationSetup"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModelSetup.Iid); + writer.WriteStartArray("iterationSetup"u8); + + foreach(var iterationSetupItem in engineeringModelSetup.IterationSetup.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(iterationSetupItem); } - writer.WriteStartArray("iterationSetup"u8); + writer.WriteEndArray(); + writer.WritePropertyName("kind"u8); + writer.WriteStringValue(engineeringModelSetup.Kind.ToString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(engineeringModelSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(engineeringModelSetup.Name); + writer.WriteStartArray("participant"u8); - if(value is IEnumerable objectListIterationSetup) + foreach(var participantItem in engineeringModelSetup.Participant.OrderBy(x => x, this.GuidComparer)) { - foreach(var iterationSetupItem in objectListIterationSetup.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(iterationSetupItem); - } + writer.WriteStringValue(participantItem); } - + writer.WriteEndArray(); - break; - case "kind": - if(!AllowedVersionsPerProperty["kind"].Contains(requestedVersion)) + writer.WriteStartArray("requiredRdl"u8); + + foreach(var requiredRdlItem in engineeringModelSetup.RequiredRdl.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(requiredRdlItem); } - writer.WritePropertyName("kind"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModelSetup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(engineeringModelSetup.ShortName); + writer.WritePropertyName("sourceEngineeringModelSetupIid"u8); + + if(engineeringModelSetup.SourceEngineeringModelSetupIid.HasValue) { - writer.WriteStringValue(((EngineeringModelKind)value).ToString()); + writer.WriteStringValue(engineeringModelSetup.SourceEngineeringModelSetupIid.Value); } else { writer.WriteNullValue(); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WritePropertyName("studyPhase"u8); + writer.WriteStringValue(engineeringModelSetup.StudyPhase.ToString()); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModelSetup for Version 1.2.0"); + writer.WriteStartArray("activeDomain"u8); + + foreach(var activeDomainItem in engineeringModelSetup.ActiveDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(activeDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in engineeringModelSetup.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModelSetup.ClassKind.ToString()); + writer.WritePropertyName("defaultOrganizationalParticipant"u8); + + if(engineeringModelSetup.DefaultOrganizationalParticipant.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(engineeringModelSetup.DefaultOrganizationalParticipant.Value); } else { writer.WriteNullValue(); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in engineeringModelSetup.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("engineeringModelIid"u8); + writer.WriteStringValue(engineeringModelSetup.EngineeringModelIid); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in engineeringModelSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModelSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "organizationalparticipant": - if(!AllowedVersionsPerProperty["organizationalParticipant"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in engineeringModelSetup.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WriteStartArray("organizationalParticipant"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModelSetup.Iid); + writer.WriteStartArray("iterationSetup"u8); - if(value is IEnumerable objectListOrganizationalParticipant) + foreach(var iterationSetupItem in engineeringModelSetup.IterationSetup.OrderBy(x => x, this.GuidComparer)) { - foreach(var organizationalParticipantItem in objectListOrganizationalParticipant.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(organizationalParticipantItem); - } + writer.WriteStringValue(iterationSetupItem); } - + writer.WriteEndArray(); - break; - case "participant": - if(!AllowedVersionsPerProperty["participant"].Contains(requestedVersion)) + writer.WritePropertyName("kind"u8); + writer.WriteStringValue(engineeringModelSetup.Kind.ToString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(engineeringModelSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(engineeringModelSetup.Name); + writer.WriteStartArray("organizationalParticipant"u8); + + foreach(var organizationalParticipantItem in engineeringModelSetup.OrganizationalParticipant.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(organizationalParticipantItem); } + writer.WriteEndArray(); writer.WriteStartArray("participant"u8); - if(value is IEnumerable objectListParticipant) + foreach(var participantItem in engineeringModelSetup.Participant.OrderBy(x => x, this.GuidComparer)) { - foreach(var participantItem in objectListParticipant.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(participantItem); - } + writer.WriteStringValue(participantItem); } - + writer.WriteEndArray(); - break; - case "requiredrdl": - if(!AllowedVersionsPerProperty["requiredRdl"].Contains(requestedVersion)) + writer.WriteStartArray("requiredRdl"u8); + + foreach(var requiredRdlItem in engineeringModelSetup.RequiredRdl.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(requiredRdlItem); } - writer.WriteStartArray("requiredRdl"u8); + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModelSetup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(engineeringModelSetup.ShortName); + writer.WritePropertyName("sourceEngineeringModelSetupIid"u8); - if(value is IEnumerable objectListRequiredRdl) + if(engineeringModelSetup.SourceEngineeringModelSetupIid.HasValue) { - foreach(var requiredRdlItem in objectListRequiredRdl.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(requiredRdlItem); - } + writer.WriteStringValue(engineeringModelSetup.SourceEngineeringModelSetupIid.Value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("studyPhase"u8); + writer.WriteStringValue(engineeringModelSetup.StudyPhase.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(engineeringModelSetup.ThingPreference); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing EngineeringModelSetup for Version 1.3.0"); + writer.WriteStartArray("activeDomain"u8); + + foreach(var activeDomainItem in engineeringModelSetup.ActiveDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(activeDomainItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); + + if(engineeringModelSetup.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(engineeringModelSetup.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in engineeringModelSetup.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(engineeringModelSetup.ClassKind.ToString()); + writer.WritePropertyName("defaultOrganizationalParticipant"u8); + + if(engineeringModelSetup.DefaultOrganizationalParticipant.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(engineeringModelSetup.DefaultOrganizationalParticipant.Value); } else { writer.WriteNullValue(); } - break; - case "sourceengineeringmodelsetupiid": - if(!AllowedVersionsPerProperty["sourceEngineeringModelSetupIid"].Contains(requestedVersion)) + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in engineeringModelSetup.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("sourceEngineeringModelSetupIid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("engineeringModelIid"u8); + writer.WriteStringValue(engineeringModelSetup.EngineeringModelIid); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in engineeringModelSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in engineeringModelSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "studyphase": - if(!AllowedVersionsPerProperty["studyPhase"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in engineeringModelSetup.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("studyPhase"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(engineeringModelSetup.Iid); + writer.WriteStartArray("iterationSetup"u8); + + foreach(var iterationSetupItem in engineeringModelSetup.IterationSetup.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((StudyPhaseKind)value).ToString()); + writer.WriteStringValue(iterationSetupItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("kind"u8); + writer.WriteStringValue(engineeringModelSetup.Kind.ToString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(engineeringModelSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(engineeringModelSetup.Name); + writer.WriteStartArray("organizationalParticipant"u8); + + foreach(var organizationalParticipantItem in engineeringModelSetup.OrganizationalParticipant.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(organizationalParticipantItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("participant"u8); + + foreach(var participantItem in engineeringModelSetup.Participant.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(participantItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("requiredRdl"u8); + + foreach(var requiredRdlItem in engineeringModelSetup.RequiredRdl.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(requiredRdlItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(engineeringModelSetup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(engineeringModelSetup.ShortName); + writer.WritePropertyName("sourceEngineeringModelSetupIid"u8); + + if(engineeringModelSetup.SourceEngineeringModelSetupIid.HasValue) + { + writer.WriteStringValue(engineeringModelSetup.SourceEngineeringModelSetupIid.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("studyPhase"u8); + writer.WriteStringValue(engineeringModelSetup.StudyPhase.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(engineeringModelSetup.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the EngineeringModelSetup"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "activeDomain", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "defaultOrganizationalParticipant", new []{ "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "engineeringModelIid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iterationSetup", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "kind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "organizationalParticipant", new []{ "1.2.0", "1.3.0" }}, - { "participant", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "requiredRdl", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "sourceEngineeringModelSetupIid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "studyPhase", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/EnumerationParameterTypeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/EnumerationParameterTypeSerializer.cs index 64c28122..17bfcb6e 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/EnumerationParameterTypeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/EnumerationParameterTypeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,393 +50,317 @@ namespace CDP4JsonSerializer public class EnumerationParameterTypeSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not EnumerationParameterType enumerationParameterType) - { - throw new ArgumentException("The thing shall be a EnumerationParameterType", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of EnumerationParameterType since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing EnumerationParameterType for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in enumerationParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("allowMultiSelect"u8); - writer.WriteBooleanValue(enumerationParameterType.AllowMultiSelect); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in enumerationParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(enumerationParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in enumerationParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in enumerationParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(enumerationParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(enumerationParameterType.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(enumerationParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(enumerationParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(enumerationParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(enumerationParameterType.Symbol); - writer.WriteStartArray("valueDefinition"u8); + writer.WriteEndArray(); + break; + case "allowmultiselect": + var allowedVersionsForAllowMultiSelect = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var valueDefinitionItem in enumerationParameterType.ValueDefinition.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForAllowMultiSelect.Contains(requestedVersion)) { - writer.WriteOrderedItem(valueDefinitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("allowMultiSelect"u8); + if(value != null) + { + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); + } + break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing EnumerationParameterType for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in enumerationParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("allowMultiSelect"u8); - writer.WriteBooleanValue(enumerationParameterType.AllowMultiSelect); writer.WriteStartArray("category"u8); - foreach(var categoryItem in enumerationParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(enumerationParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in enumerationParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in enumerationParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in enumerationParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in enumerationParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(enumerationParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(enumerationParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(enumerationParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(enumerationParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(enumerationParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(enumerationParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(enumerationParameterType.Symbol); - writer.WriteStartArray("valueDefinition"u8); + writer.WriteStartArray("definition"u8); - foreach(var valueDefinitionItem in enumerationParameterType.ValueDefinition.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteOrderedItem(valueDefinitionItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing EnumerationParameterType for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in enumerationParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("allowMultiSelect"u8); - writer.WriteBooleanValue(enumerationParameterType.AllowMultiSelect); - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in enumerationParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(enumerationParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in enumerationParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in enumerationParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in enumerationParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in enumerationParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(enumerationParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(enumerationParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(enumerationParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(enumerationParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(enumerationParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(enumerationParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(enumerationParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(enumerationParameterType.ThingPreference); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in enumerationParameterType.ValueDefinition.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(valueDefinitionItem); - } - writer.WriteEndArray(); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing EnumerationParameterType for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(enumerationParameterType.Actor.HasValue) - { - writer.WriteStringValue(enumerationParameterType.Actor.Value); - } - else + case "iid": + var allowedVersionsForIid = new List { - writer.WriteNullValue(); - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in enumerationParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("allowMultiSelect"u8); - writer.WriteBooleanValue(enumerationParameterType.AllowMultiSelect); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in enumerationParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(enumerationParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in enumerationParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in enumerationParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in enumerationParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in enumerationParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(enumerationParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(enumerationParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(enumerationParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(enumerationParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(enumerationParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(enumerationParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(enumerationParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(enumerationParameterType.ThingPreference); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in enumerationParameterType.ValueDefinition.OrderBy(x => x, this.OrderedItemComparer)) + else { - writer.WriteOrderedItem(valueDefinitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -445,35 +368,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "allowmultiselect": - if(!AllowedVersionsPerProperty["allowMultiSelect"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("allowMultiSelect"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -481,35 +394,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } - - writer.WriteStartArray("category"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListCategory) - { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -517,89 +420,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "symbol": + var allowedVersionsForSymbol = new List { - return; - } - - writer.WriteStartArray("hyperLink"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("symbol"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -607,17 +472,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isDeprecated"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -625,161 +496,373 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "valuedefinition": + var allowedVersionsForValueDefinition = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + if(!allowedVersionsForValueDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + return; } - else + + writer.WriteStartArray("valueDefinition"u8); + + if(value is IEnumerable objectListValueDefinition) { - writer.WriteNullValue(); + foreach(var valueDefinitionItem in objectListValueDefinition.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(valueDefinitionItem); + } } - + + writer.WriteEndArray(); break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the EnumerationParameterType"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not EnumerationParameterType enumerationParameterType) + { + throw new ArgumentException("The thing shall be a EnumerationParameterType", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of EnumerationParameterType since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing EnumerationParameterType for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in enumerationParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("allowMultiSelect"u8); + writer.WriteBooleanValue(enumerationParameterType.AllowMultiSelect); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in enumerationParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(enumerationParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in enumerationParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in enumerationParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(enumerationParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(enumerationParameterType.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(enumerationParameterType.Name); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(enumerationParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(enumerationParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(enumerationParameterType.Symbol); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in enumerationParameterType.ValueDefinition.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteOrderedItem(valueDefinitionItem); } - else + + writer.WriteEndArray(); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing EnumerationParameterType for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in enumerationParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(aliasItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("allowMultiSelect"u8); + writer.WriteBooleanValue(enumerationParameterType.AllowMultiSelect); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in enumerationParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(enumerationParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in enumerationParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in enumerationParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in enumerationParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("symbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in enumerationParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(enumerationParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(enumerationParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(enumerationParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(enumerationParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(enumerationParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(enumerationParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(enumerationParameterType.Symbol); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in enumerationParameterType.ValueDefinition.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(valueDefinitionItem); } + writer.WriteEndArray(); break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing EnumerationParameterType for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in enumerationParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("allowMultiSelect"u8); + writer.WriteBooleanValue(enumerationParameterType.AllowMultiSelect); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in enumerationParameterType.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(enumerationParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in enumerationParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in enumerationParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in enumerationParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in enumerationParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(enumerationParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(enumerationParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(enumerationParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(enumerationParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(enumerationParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(enumerationParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(enumerationParameterType.Symbol); writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteStringValue(enumerationParameterType.ThingPreference); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in enumerationParameterType.ValueDefinition.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteStringValue((string)value); + writer.WriteOrderedItem(valueDefinitionItem); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing EnumerationParameterType for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(enumerationParameterType.Actor.HasValue) + { + writer.WriteStringValue(enumerationParameterType.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "valuedefinition": - if(!AllowedVersionsPerProperty["valueDefinition"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in enumerationParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("allowMultiSelect"u8); + writer.WriteBooleanValue(enumerationParameterType.AllowMultiSelect); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in enumerationParameterType.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(enumerationParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in enumerationParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in enumerationParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in enumerationParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in enumerationParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(enumerationParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(enumerationParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(enumerationParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(enumerationParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(enumerationParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(enumerationParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(enumerationParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(enumerationParameterType.ThingPreference); writer.WriteStartArray("valueDefinition"u8); - if(value is IEnumerable objectListValueDefinition) + foreach(var valueDefinitionItem in enumerationParameterType.ValueDefinition.OrderBy(x => x, this.OrderedItemComparer)) { - foreach(var valueDefinitionItem in objectListValueDefinition.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(valueDefinitionItem); - } + writer.WriteOrderedItem(valueDefinitionItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the EnumerationParameterType"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "allowMultiSelect", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "valueDefinition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/EnumerationValueDefinitionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/EnumerationValueDefinitionSerializer.cs index ccb84698..03c22ebb 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/EnumerationValueDefinitionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/EnumerationValueDefinitionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,6 +49,354 @@ namespace CDP4JsonSerializer /// public class EnumerationValueDefinitionSerializer : BaseThingSerializer, IThingSerializer { + /// + /// Serialize a value for a property into a + /// + /// The name of the property to serialize + /// The object value to serialize + /// The + /// The that has been requested for the serialization + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + var requestedVersion = requestedDataModelVersion.ToString(3); + + switch(propertyName.ToLower()) + { + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("alias"u8); + + if(value is IEnumerable objectListAlias) + { + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + } + + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("classKind"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } + + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefinition.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("definition"u8); + + if(value is IEnumerable objectListDefinition) + { + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + } + + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } + + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("name"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("shortName"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the EnumerationValueDefinition"); + } + } + /// /// Serializes a into an /// @@ -76,7 +423,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM switch(requestedDataModelVersion.ToString(3)) { case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing EnumerationValueDefinition for Version 1.0.0"); + Logger.Log(LogLevel.Debug, "Serializing EnumerationValueDefinition for Version 1.0.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in enumerationValueDefinition.Alias.OrderBy(x => x, this.GuidComparer)) @@ -85,7 +432,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(enumerationValueDefinition.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -96,7 +442,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in enumerationValueDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -105,7 +450,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(enumerationValueDefinition.Iid); writer.WritePropertyName("name"u8); @@ -116,7 +460,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(enumerationValueDefinition.ShortName); break; case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing EnumerationValueDefinition for Version 1.1.0"); + Logger.Log(LogLevel.Debug, "Serializing EnumerationValueDefinition for Version 1.1.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in enumerationValueDefinition.Alias.OrderBy(x => x, this.GuidComparer)) @@ -125,7 +469,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(enumerationValueDefinition.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -136,7 +479,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in enumerationValueDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -145,7 +487,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in enumerationValueDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -154,7 +495,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in enumerationValueDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -163,7 +503,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(enumerationValueDefinition.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -176,7 +515,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(enumerationValueDefinition.ShortName); break; case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing EnumerationValueDefinition for Version 1.2.0"); + Logger.Log(LogLevel.Debug, "Serializing EnumerationValueDefinition for Version 1.2.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in enumerationValueDefinition.Alias.OrderBy(x => x, this.GuidComparer)) @@ -185,7 +524,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(enumerationValueDefinition.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -196,7 +534,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in enumerationValueDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -205,7 +542,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in enumerationValueDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -214,7 +550,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in enumerationValueDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -223,7 +558,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(enumerationValueDefinition.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -238,7 +572,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(enumerationValueDefinition.ThingPreference); break; case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing EnumerationValueDefinition for Version 1.3.0"); + Logger.Log(LogLevel.Debug, "Serializing EnumerationValueDefinition for Version 1.3.0"); writer.WritePropertyName("actor"u8); if(enumerationValueDefinition.Actor.HasValue) @@ -258,7 +592,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(enumerationValueDefinition.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -269,7 +602,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in enumerationValueDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -278,7 +610,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in enumerationValueDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -287,7 +618,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in enumerationValueDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -296,7 +626,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(enumerationValueDefinition.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -316,279 +645,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteEndObject(); } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("name"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("shortName"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the EnumerationValueDefinition"); - } - } - - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ExclusiveOrExpressionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ExclusiveOrExpressionSerializer.cs index 7efaec89..53ec4571 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ExclusiveOrExpressionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ExclusiveOrExpressionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,185 +49,6 @@ namespace CDP4JsonSerializer /// public class ExclusiveOrExpressionSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ExclusiveOrExpression exclusiveOrExpression) - { - throw new ArgumentException("The thing shall be a ExclusiveOrExpression", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ExclusiveOrExpression since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ExclusiveOrExpression for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(exclusiveOrExpression.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(exclusiveOrExpression.Iid); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(exclusiveOrExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in exclusiveOrExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ExclusiveOrExpression for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(exclusiveOrExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in exclusiveOrExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in exclusiveOrExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(exclusiveOrExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(exclusiveOrExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(exclusiveOrExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in exclusiveOrExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ExclusiveOrExpression for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(exclusiveOrExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in exclusiveOrExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in exclusiveOrExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(exclusiveOrExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(exclusiveOrExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(exclusiveOrExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in exclusiveOrExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(exclusiveOrExpression.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ExclusiveOrExpression for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(exclusiveOrExpression.Actor.HasValue) - { - writer.WriteStringValue(exclusiveOrExpression.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(exclusiveOrExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in exclusiveOrExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in exclusiveOrExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(exclusiveOrExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(exclusiveOrExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(exclusiveOrExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in exclusiveOrExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(exclusiveOrExpression.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -236,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -244,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -262,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -280,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -298,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -316,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -334,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -352,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -370,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "term": - if(!AllowedVersionsPerProperty["term"].Contains(requestedVersion)) + var allowedVersionsForTerm = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTerm.Contains(requestedVersion)) { return; } @@ -388,7 +265,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -411,20 +294,173 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "term", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not ExclusiveOrExpression exclusiveOrExpression) + { + throw new ArgumentException("The thing shall be a ExclusiveOrExpression", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ExclusiveOrExpression since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ExclusiveOrExpression for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(exclusiveOrExpression.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(exclusiveOrExpression.Iid); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(exclusiveOrExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in exclusiveOrExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ExclusiveOrExpression for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(exclusiveOrExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in exclusiveOrExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in exclusiveOrExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(exclusiveOrExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(exclusiveOrExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(exclusiveOrExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in exclusiveOrExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ExclusiveOrExpression for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(exclusiveOrExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in exclusiveOrExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in exclusiveOrExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(exclusiveOrExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(exclusiveOrExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(exclusiveOrExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in exclusiveOrExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(exclusiveOrExpression.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ExclusiveOrExpression for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(exclusiveOrExpression.Actor.HasValue) + { + writer.WriteStringValue(exclusiveOrExpression.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(exclusiveOrExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in exclusiveOrExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in exclusiveOrExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(exclusiveOrExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(exclusiveOrExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(exclusiveOrExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in exclusiveOrExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(exclusiveOrExpression.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ExternalIdentifierMapSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ExternalIdentifierMapSerializer.cs index 11162526..90f4cc19 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ExternalIdentifierMapSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ExternalIdentifierMapSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,269 +49,6 @@ namespace CDP4JsonSerializer /// public class ExternalIdentifierMapSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ExternalIdentifierMap externalIdentifierMap) - { - throw new ArgumentException("The thing shall be a ExternalIdentifierMap", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ExternalIdentifierMap since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ExternalIdentifierMap for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(externalIdentifierMap.ClassKind.ToString()); - writer.WriteStartArray("correspondence"u8); - - foreach(var correspondenceItem in externalIdentifierMap.Correspondence.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(correspondenceItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("externalFormat"u8); - - if(externalIdentifierMap.ExternalFormat.HasValue) - { - writer.WriteStringValue(externalIdentifierMap.ExternalFormat.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("externalModelName"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalModelName); - writer.WritePropertyName("externalToolName"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalToolName); - writer.WritePropertyName("externalToolVersion"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalToolVersion); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(externalIdentifierMap.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(externalIdentifierMap.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(externalIdentifierMap.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(externalIdentifierMap.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ExternalIdentifierMap for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(externalIdentifierMap.ClassKind.ToString()); - writer.WriteStartArray("correspondence"u8); - - foreach(var correspondenceItem in externalIdentifierMap.Correspondence.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(correspondenceItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in externalIdentifierMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in externalIdentifierMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("externalFormat"u8); - - if(externalIdentifierMap.ExternalFormat.HasValue) - { - writer.WriteStringValue(externalIdentifierMap.ExternalFormat.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("externalModelName"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalModelName); - writer.WritePropertyName("externalToolName"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalToolName); - writer.WritePropertyName("externalToolVersion"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalToolVersion); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(externalIdentifierMap.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(externalIdentifierMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(externalIdentifierMap.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(externalIdentifierMap.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(externalIdentifierMap.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ExternalIdentifierMap for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(externalIdentifierMap.ClassKind.ToString()); - writer.WriteStartArray("correspondence"u8); - - foreach(var correspondenceItem in externalIdentifierMap.Correspondence.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(correspondenceItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in externalIdentifierMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in externalIdentifierMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("externalFormat"u8); - - if(externalIdentifierMap.ExternalFormat.HasValue) - { - writer.WriteStringValue(externalIdentifierMap.ExternalFormat.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("externalModelName"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalModelName); - writer.WritePropertyName("externalToolName"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalToolName); - writer.WritePropertyName("externalToolVersion"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalToolVersion); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(externalIdentifierMap.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(externalIdentifierMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(externalIdentifierMap.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(externalIdentifierMap.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(externalIdentifierMap.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(externalIdentifierMap.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ExternalIdentifierMap for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(externalIdentifierMap.Actor.HasValue) - { - writer.WriteStringValue(externalIdentifierMap.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(externalIdentifierMap.ClassKind.ToString()); - writer.WriteStartArray("correspondence"u8); - - foreach(var correspondenceItem in externalIdentifierMap.Correspondence.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(correspondenceItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in externalIdentifierMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in externalIdentifierMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("externalFormat"u8); - - if(externalIdentifierMap.ExternalFormat.HasValue) - { - writer.WriteStringValue(externalIdentifierMap.ExternalFormat.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("externalModelName"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalModelName); - writer.WritePropertyName("externalToolName"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalToolName); - writer.WritePropertyName("externalToolVersion"u8); - writer.WriteStringValue(externalIdentifierMap.ExternalToolVersion); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(externalIdentifierMap.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(externalIdentifierMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(externalIdentifierMap.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(externalIdentifierMap.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(externalIdentifierMap.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(externalIdentifierMap.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -320,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -328,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -346,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -364,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "correspondence": - if(!AllowedVersionsPerProperty["correspondence"].Contains(requestedVersion)) + var allowedVersionsForCorrespondence = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCorrespondence.Contains(requestedVersion)) { return; } @@ -382,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -400,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -418,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "externalformat": - if(!AllowedVersionsPerProperty["externalFormat"].Contains(requestedVersion)) + var allowedVersionsForExternalFormat = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExternalFormat.Contains(requestedVersion)) { return; } @@ -436,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "externalmodelname": - if(!AllowedVersionsPerProperty["externalModelName"].Contains(requestedVersion)) + var allowedVersionsForExternalModelName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExternalModelName.Contains(requestedVersion)) { return; } @@ -454,7 +240,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "externaltoolname": - if(!AllowedVersionsPerProperty["externalToolName"].Contains(requestedVersion)) + var allowedVersionsForExternalToolName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExternalToolName.Contains(requestedVersion)) { return; } @@ -472,7 +266,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "externaltoolversion": - if(!AllowedVersionsPerProperty["externalToolVersion"].Contains(requestedVersion)) + var allowedVersionsForExternalToolVersion = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExternalToolVersion.Contains(requestedVersion)) { return; } @@ -490,7 +292,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -508,7 +318,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -526,7 +343,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -544,7 +369,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -562,7 +395,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -580,7 +421,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -603,26 +450,257 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "correspondence", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "externalFormat", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "externalModelName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "externalToolName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "externalToolVersion", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not ExternalIdentifierMap externalIdentifierMap) + { + throw new ArgumentException("The thing shall be a ExternalIdentifierMap", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ExternalIdentifierMap since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ExternalIdentifierMap for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(externalIdentifierMap.ClassKind.ToString()); + writer.WriteStartArray("correspondence"u8); + + foreach(var correspondenceItem in externalIdentifierMap.Correspondence.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(correspondenceItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("externalFormat"u8); + + if(externalIdentifierMap.ExternalFormat.HasValue) + { + writer.WriteStringValue(externalIdentifierMap.ExternalFormat.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("externalModelName"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalModelName); + writer.WritePropertyName("externalToolName"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalToolName); + writer.WritePropertyName("externalToolVersion"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalToolVersion); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(externalIdentifierMap.Iid); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(externalIdentifierMap.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(externalIdentifierMap.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(externalIdentifierMap.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ExternalIdentifierMap for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(externalIdentifierMap.ClassKind.ToString()); + writer.WriteStartArray("correspondence"u8); + + foreach(var correspondenceItem in externalIdentifierMap.Correspondence.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(correspondenceItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in externalIdentifierMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in externalIdentifierMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("externalFormat"u8); + + if(externalIdentifierMap.ExternalFormat.HasValue) + { + writer.WriteStringValue(externalIdentifierMap.ExternalFormat.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("externalModelName"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalModelName); + writer.WritePropertyName("externalToolName"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalToolName); + writer.WritePropertyName("externalToolVersion"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalToolVersion); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(externalIdentifierMap.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(externalIdentifierMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(externalIdentifierMap.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(externalIdentifierMap.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(externalIdentifierMap.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ExternalIdentifierMap for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(externalIdentifierMap.ClassKind.ToString()); + writer.WriteStartArray("correspondence"u8); + + foreach(var correspondenceItem in externalIdentifierMap.Correspondence.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(correspondenceItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in externalIdentifierMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in externalIdentifierMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("externalFormat"u8); + + if(externalIdentifierMap.ExternalFormat.HasValue) + { + writer.WriteStringValue(externalIdentifierMap.ExternalFormat.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("externalModelName"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalModelName); + writer.WritePropertyName("externalToolName"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalToolName); + writer.WritePropertyName("externalToolVersion"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalToolVersion); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(externalIdentifierMap.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(externalIdentifierMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(externalIdentifierMap.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(externalIdentifierMap.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(externalIdentifierMap.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(externalIdentifierMap.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ExternalIdentifierMap for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(externalIdentifierMap.Actor.HasValue) + { + writer.WriteStringValue(externalIdentifierMap.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(externalIdentifierMap.ClassKind.ToString()); + writer.WriteStartArray("correspondence"u8); + + foreach(var correspondenceItem in externalIdentifierMap.Correspondence.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(correspondenceItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in externalIdentifierMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in externalIdentifierMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("externalFormat"u8); + + if(externalIdentifierMap.ExternalFormat.HasValue) + { + writer.WriteStringValue(externalIdentifierMap.ExternalFormat.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("externalModelName"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalModelName); + writer.WritePropertyName("externalToolName"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalToolName); + writer.WritePropertyName("externalToolVersion"u8); + writer.WriteStringValue(externalIdentifierMap.ExternalToolVersion); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(externalIdentifierMap.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(externalIdentifierMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(externalIdentifierMap.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(externalIdentifierMap.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(externalIdentifierMap.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(externalIdentifierMap.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/FileRevisionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/FileRevisionSerializer.cs index 3685cd36..3fe0cb97 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/FileRevisionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/FileRevisionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,261 +49,6 @@ namespace CDP4JsonSerializer /// public class FileRevisionSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not FileRevision fileRevision) - { - throw new ArgumentException("The thing shall be a FileRevision", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of FileRevision since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing FileRevision for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(fileRevision.ClassKind.ToString()); - writer.WritePropertyName("containingFolder"u8); - - if(fileRevision.ContainingFolder.HasValue) - { - writer.WriteStringValue(fileRevision.ContainingFolder.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("contentHash"u8); - writer.WriteStringValue(fileRevision.ContentHash); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(fileRevision.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("creator"u8); - writer.WriteStringValue(fileRevision.Creator); - writer.WriteStartArray("fileType"u8); - - foreach(var fileTypeItem in fileRevision.FileType.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(fileTypeItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(fileRevision.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(fileRevision.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(fileRevision.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing FileRevision for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(fileRevision.ClassKind.ToString()); - writer.WritePropertyName("containingFolder"u8); - - if(fileRevision.ContainingFolder.HasValue) - { - writer.WriteStringValue(fileRevision.ContainingFolder.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("contentHash"u8); - writer.WriteStringValue(fileRevision.ContentHash); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(fileRevision.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("creator"u8); - writer.WriteStringValue(fileRevision.Creator); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in fileRevision.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in fileRevision.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("fileType"u8); - - foreach(var fileTypeItem in fileRevision.FileType.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(fileTypeItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(fileRevision.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(fileRevision.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(fileRevision.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(fileRevision.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing FileRevision for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(fileRevision.ClassKind.ToString()); - writer.WritePropertyName("containingFolder"u8); - - if(fileRevision.ContainingFolder.HasValue) - { - writer.WriteStringValue(fileRevision.ContainingFolder.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("contentHash"u8); - writer.WriteStringValue(fileRevision.ContentHash); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(fileRevision.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("creator"u8); - writer.WriteStringValue(fileRevision.Creator); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in fileRevision.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in fileRevision.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("fileType"u8); - - foreach(var fileTypeItem in fileRevision.FileType.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(fileTypeItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(fileRevision.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(fileRevision.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(fileRevision.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(fileRevision.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(fileRevision.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing FileRevision for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(fileRevision.Actor.HasValue) - { - writer.WriteStringValue(fileRevision.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(fileRevision.ClassKind.ToString()); - writer.WritePropertyName("containingFolder"u8); - - if(fileRevision.ContainingFolder.HasValue) - { - writer.WriteStringValue(fileRevision.ContainingFolder.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("contentHash"u8); - writer.WriteStringValue(fileRevision.ContentHash); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(fileRevision.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("creator"u8); - writer.WriteStringValue(fileRevision.Creator); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in fileRevision.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in fileRevision.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("fileType"u8); - - foreach(var fileTypeItem in fileRevision.FileType.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(fileTypeItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(fileRevision.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(fileRevision.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(fileRevision.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(fileRevision.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(fileRevision.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -312,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -320,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -338,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -356,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "containingfolder": - if(!AllowedVersionsPerProperty["containingFolder"].Contains(requestedVersion)) + var allowedVersionsForContainingFolder = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContainingFolder.Contains(requestedVersion)) { return; } @@ -374,7 +138,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "contenthash": - if(!AllowedVersionsPerProperty["contentHash"].Contains(requestedVersion)) + var allowedVersionsForContentHash = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContentHash.Contains(requestedVersion)) { return; } @@ -392,7 +164,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -410,7 +190,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "creator": - if(!AllowedVersionsPerProperty["creator"].Contains(requestedVersion)) + var allowedVersionsForCreator = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreator.Contains(requestedVersion)) { return; } @@ -428,7 +216,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -446,7 +241,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -464,7 +266,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "filetype": - if(!AllowedVersionsPerProperty["fileType"].Contains(requestedVersion)) + var allowedVersionsForFileType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFileType.Contains(requestedVersion)) { return; } @@ -482,7 +292,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -500,7 +318,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -518,7 +343,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -536,7 +369,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -554,7 +395,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -577,25 +424,249 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "containingFolder", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "contentHash", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "creator", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fileType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not FileRevision fileRevision) + { + throw new ArgumentException("The thing shall be a FileRevision", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of FileRevision since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing FileRevision for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(fileRevision.ClassKind.ToString()); + writer.WritePropertyName("containingFolder"u8); + + if(fileRevision.ContainingFolder.HasValue) + { + writer.WriteStringValue(fileRevision.ContainingFolder.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("contentHash"u8); + writer.WriteStringValue(fileRevision.ContentHash); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(fileRevision.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("creator"u8); + writer.WriteStringValue(fileRevision.Creator); + writer.WriteStartArray("fileType"u8); + + foreach(var fileTypeItem in fileRevision.FileType.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(fileTypeItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(fileRevision.Iid); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(fileRevision.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(fileRevision.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing FileRevision for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(fileRevision.ClassKind.ToString()); + writer.WritePropertyName("containingFolder"u8); + + if(fileRevision.ContainingFolder.HasValue) + { + writer.WriteStringValue(fileRevision.ContainingFolder.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("contentHash"u8); + writer.WriteStringValue(fileRevision.ContentHash); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(fileRevision.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("creator"u8); + writer.WriteStringValue(fileRevision.Creator); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in fileRevision.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in fileRevision.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("fileType"u8); + + foreach(var fileTypeItem in fileRevision.FileType.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(fileTypeItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(fileRevision.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(fileRevision.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(fileRevision.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(fileRevision.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing FileRevision for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(fileRevision.ClassKind.ToString()); + writer.WritePropertyName("containingFolder"u8); + + if(fileRevision.ContainingFolder.HasValue) + { + writer.WriteStringValue(fileRevision.ContainingFolder.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("contentHash"u8); + writer.WriteStringValue(fileRevision.ContentHash); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(fileRevision.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("creator"u8); + writer.WriteStringValue(fileRevision.Creator); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in fileRevision.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in fileRevision.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("fileType"u8); + + foreach(var fileTypeItem in fileRevision.FileType.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(fileTypeItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(fileRevision.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(fileRevision.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(fileRevision.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(fileRevision.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(fileRevision.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing FileRevision for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(fileRevision.Actor.HasValue) + { + writer.WriteStringValue(fileRevision.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(fileRevision.ClassKind.ToString()); + writer.WritePropertyName("containingFolder"u8); + + if(fileRevision.ContainingFolder.HasValue) + { + writer.WriteStringValue(fileRevision.ContainingFolder.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("contentHash"u8); + writer.WriteStringValue(fileRevision.ContentHash); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(fileRevision.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("creator"u8); + writer.WriteStringValue(fileRevision.Creator); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in fileRevision.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in fileRevision.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("fileType"u8); + + foreach(var fileTypeItem in fileRevision.FileType.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(fileTypeItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(fileRevision.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(fileRevision.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(fileRevision.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(fileRevision.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(fileRevision.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/FileSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/FileSerializer.cs index 0de93fab..402554d0 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/FileSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/FileSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,6 +49,328 @@ namespace CDP4JsonSerializer /// public class FileSerializer : BaseThingSerializer, IThingSerializer { + /// + /// Serialize a value for a property into a + /// + /// The name of the property to serialize + /// The object value to serialize + /// The + /// The that has been requested for the serialization + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + var requestedVersion = requestedDataModelVersion.ToString(3); + + switch(propertyName.ToLower()) + { + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("category"u8); + + if(value is IEnumerable objectListCategory) + { + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + } + + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("classKind"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } + + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + + writer.WriteEndArray(); + break; + case "filerevision": + var allowedVersionsForFileRevision = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFileRevision.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("fileRevision"u8); + + if(value is IEnumerable objectListFileRevision) + { + foreach(var fileRevisionItem in objectListFileRevision.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileRevisionItem); + } + } + + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "lockedby": + var allowedVersionsForLockedBy = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLockedBy.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("lockedBy"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "owner": + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("owner"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the File"); + } + } + /// /// Serializes a into an /// @@ -76,7 +397,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM switch(requestedDataModelVersion.ToString(3)) { case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing File for Version 1.0.0"); + Logger.Log(LogLevel.Debug, "Serializing File for Version 1.0.0"); writer.WriteStartArray("category"u8); foreach(var categoryItem in file.Category.OrderBy(x => x, this.GuidComparer)) @@ -85,7 +406,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(file.ClassKind.ToString()); writer.WriteStartArray("fileRevision"u8); @@ -96,7 +416,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(file.Iid); writer.WritePropertyName("lockedBy"u8); @@ -116,7 +435,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNumberValue(file.RevisionNumber); break; case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing File for Version 1.1.0"); + Logger.Log(LogLevel.Debug, "Serializing File for Version 1.1.0"); writer.WriteStartArray("category"u8); foreach(var categoryItem in file.Category.OrderBy(x => x, this.GuidComparer)) @@ -125,7 +444,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(file.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -136,7 +454,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in file.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -145,7 +462,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("fileRevision"u8); foreach(var fileRevisionItem in file.FileRevision.OrderBy(x => x, this.GuidComparer)) @@ -154,7 +470,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(file.Iid); writer.WritePropertyName("lockedBy"u8); @@ -176,7 +491,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNumberValue(file.RevisionNumber); break; case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing File for Version 1.2.0"); + Logger.Log(LogLevel.Debug, "Serializing File for Version 1.2.0"); writer.WriteStartArray("category"u8); foreach(var categoryItem in file.Category.OrderBy(x => x, this.GuidComparer)) @@ -185,7 +500,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(file.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -196,7 +510,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in file.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -205,7 +518,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("fileRevision"u8); foreach(var fileRevisionItem in file.FileRevision.OrderBy(x => x, this.GuidComparer)) @@ -214,7 +526,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(file.Iid); writer.WritePropertyName("lockedBy"u8); @@ -238,7 +549,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(file.ThingPreference); break; case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing File for Version 1.3.0"); + Logger.Log(LogLevel.Debug, "Serializing File for Version 1.3.0"); writer.WritePropertyName("actor"u8); if(file.Actor.HasValue) @@ -258,7 +569,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(file.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -269,7 +579,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in file.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -278,7 +587,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("fileRevision"u8); foreach(var fileRevisionItem in file.FileRevision.OrderBy(x => x, this.GuidComparer)) @@ -287,7 +595,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(file.Iid); writer.WritePropertyName("lockedBy"u8); @@ -316,260 +623,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteEndObject(); } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) - { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "filerevision": - if(!AllowedVersionsPerProperty["fileRevision"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("fileRevision"u8); - - if(value is IEnumerable objectListFileRevision) - { - foreach(var fileRevisionItem in objectListFileRevision.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(fileRevisionItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "lockedby": - if(!AllowedVersionsPerProperty["lockedBy"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("lockedBy"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("owner"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the File"); - } - } - - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fileRevision", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "lockedBy", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/FileTypeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/FileTypeSerializer.cs index abb0ef31..71b13359 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/FileTypeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/FileTypeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,349 +50,292 @@ namespace CDP4JsonSerializer public class FileTypeSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not FileType fileType) - { - throw new ArgumentException("The thing shall be a FileType", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of FileType since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing FileType for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in fileType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in fileType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(fileType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in fileType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("extension"u8); - writer.WriteStringValue(fileType.Extension); - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in fileType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(fileType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(fileType.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(fileType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(fileType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(fileType.ShortName); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing FileType for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in fileType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in fileType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(fileType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in fileType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in fileType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in fileType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("extension"u8); - writer.WriteStringValue(fileType.Extension); - writer.WriteStartArray("hyperLink"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in fileType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(fileType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(fileType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(fileType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(fileType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(fileType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(fileType.ShortName); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing FileType for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("definition"u8); - foreach(var aliasItem in fileType.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(aliasItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in fileType.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(fileType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in fileType.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in fileType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in fileType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("extension"u8); - writer.WriteStringValue(fileType.Extension); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "extension": + var allowedVersionsForExtension = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in fileType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExtension.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("extension"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(fileType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(fileType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(fileType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(fileType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(fileType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(fileType.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(fileType.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing FileType for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(fileType.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(fileType.Actor.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in fileType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var categoryItem in fileType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(fileType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in fileType.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in fileType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in fileType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("extension"u8); - writer.WriteStringValue(fileType.Extension); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in fileType.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(fileType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(fileType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(fileType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(fileType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(fileType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(fileType.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(fileType.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("isDeprecated"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteBooleanValue((bool)value); } else { @@ -401,53 +343,50 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List { - return; - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + return; } + + writer.WritePropertyName("modifiedOn"u8); - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + else { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -455,67 +394,71 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteNumberValue((int)value); } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedDomain"u8); + break; + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListExcludedDomain) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + return; } + + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "extension": - if(!AllowedVersionsPerProperty["extension"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("extension"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { @@ -527,177 +470,307 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the FileType"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not FileType fileType) + { + throw new ArgumentException("The thing shall be a FileType", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of FileType since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing FileType for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in fileType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var categoryItem in fileType.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(fileType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in fileType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } + writer.WriteEndArray(); + writer.WritePropertyName("extension"u8); + writer.WriteStringValue(fileType.Extension); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in fileType.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteStringValue(fileType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(fileType.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(fileType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(fileType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(fileType.ShortName); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing FileType for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in fileType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in fileType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(fileType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in fileType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in fileType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in fileType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("extension"u8); + writer.WriteStringValue(fileType.Extension); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in fileType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(fileType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(fileType.IsDeprecated); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteStringValue(fileType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(fileType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(fileType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(fileType.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing FileType for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in fileType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in fileType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(fileType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in fileType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in fileType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in fileType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("extension"u8); + writer.WriteStringValue(fileType.Extension); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in fileType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(fileType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(fileType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(fileType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(fileType.Name); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(fileType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(fileType.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(fileType.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing FileType for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(fileType.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(fileType.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in fileType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in fileType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(fileType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in fileType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in fileType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in fileType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("extension"u8); + writer.WriteStringValue(fileType.Extension); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in fileType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(fileType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(fileType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(fileType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(fileType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(fileType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(fileType.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(fileType.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the FileType"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "extension", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/FolderSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/FolderSerializer.cs index 084799a7..fa69502d 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/FolderSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/FolderSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,225 +49,6 @@ namespace CDP4JsonSerializer /// public class FolderSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Folder folder) - { - throw new ArgumentException("The thing shall be a Folder", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Folder since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Folder for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(folder.ClassKind.ToString()); - writer.WritePropertyName("containingFolder"u8); - - if(folder.ContainingFolder.HasValue) - { - writer.WriteStringValue(folder.ContainingFolder.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(folder.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("creator"u8); - writer.WriteStringValue(folder.Creator); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(folder.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(folder.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(folder.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(folder.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Folder for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(folder.ClassKind.ToString()); - writer.WritePropertyName("containingFolder"u8); - - if(folder.ContainingFolder.HasValue) - { - writer.WriteStringValue(folder.ContainingFolder.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(folder.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("creator"u8); - writer.WriteStringValue(folder.Creator); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in folder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in folder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(folder.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(folder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(folder.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(folder.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(folder.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Folder for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(folder.ClassKind.ToString()); - writer.WritePropertyName("containingFolder"u8); - - if(folder.ContainingFolder.HasValue) - { - writer.WriteStringValue(folder.ContainingFolder.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(folder.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("creator"u8); - writer.WriteStringValue(folder.Creator); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in folder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in folder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(folder.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(folder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(folder.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(folder.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(folder.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(folder.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Folder for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(folder.Actor.HasValue) - { - writer.WriteStringValue(folder.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(folder.ClassKind.ToString()); - writer.WritePropertyName("containingFolder"u8); - - if(folder.ContainingFolder.HasValue) - { - writer.WriteStringValue(folder.ContainingFolder.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(folder.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("creator"u8); - writer.WriteStringValue(folder.Creator); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in folder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in folder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(folder.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(folder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(folder.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(folder.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(folder.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(folder.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -276,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -284,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -302,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -320,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "containingfolder": - if(!AllowedVersionsPerProperty["containingFolder"].Contains(requestedVersion)) + var allowedVersionsForContainingFolder = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContainingFolder.Contains(requestedVersion)) { return; } @@ -338,7 +138,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -356,7 +164,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "creator": - if(!AllowedVersionsPerProperty["creator"].Contains(requestedVersion)) + var allowedVersionsForCreator = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreator.Contains(requestedVersion)) { return; } @@ -374,7 +190,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -392,7 +215,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -410,7 +240,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -428,7 +266,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -446,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -464,7 +317,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -482,7 +343,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -500,7 +369,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -523,24 +398,217 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "containingFolder", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "creator", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Folder folder) + { + throw new ArgumentException("The thing shall be a Folder", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Folder since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Folder for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(folder.ClassKind.ToString()); + writer.WritePropertyName("containingFolder"u8); + + if(folder.ContainingFolder.HasValue) + { + writer.WriteStringValue(folder.ContainingFolder.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(folder.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("creator"u8); + writer.WriteStringValue(folder.Creator); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(folder.Iid); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(folder.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(folder.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(folder.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Folder for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(folder.ClassKind.ToString()); + writer.WritePropertyName("containingFolder"u8); + + if(folder.ContainingFolder.HasValue) + { + writer.WriteStringValue(folder.ContainingFolder.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(folder.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("creator"u8); + writer.WriteStringValue(folder.Creator); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in folder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in folder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(folder.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(folder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(folder.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(folder.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(folder.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Folder for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(folder.ClassKind.ToString()); + writer.WritePropertyName("containingFolder"u8); + + if(folder.ContainingFolder.HasValue) + { + writer.WriteStringValue(folder.ContainingFolder.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(folder.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("creator"u8); + writer.WriteStringValue(folder.Creator); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in folder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in folder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(folder.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(folder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(folder.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(folder.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(folder.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(folder.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Folder for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(folder.Actor.HasValue) + { + writer.WriteStringValue(folder.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(folder.ClassKind.ToString()); + writer.WritePropertyName("containingFolder"u8); + + if(folder.ContainingFolder.HasValue) + { + writer.WriteStringValue(folder.ContainingFolder.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(folder.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("creator"u8); + writer.WriteStringValue(folder.Creator); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in folder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in folder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(folder.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(folder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(folder.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(folder.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(folder.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(folder.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/GlossarySerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/GlossarySerializer.cs index 8574105e..b6bdf9a6 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/GlossarySerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/GlossarySerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,377 +50,343 @@ namespace CDP4JsonSerializer public class GlossarySerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not Glossary glossary) - { - throw new ArgumentException("The thing shall be a Glossary", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Glossary since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Glossary for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in glossary.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in glossary.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(glossary.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in glossary.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in glossary.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(glossary.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(glossary.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(glossary.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(glossary.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(glossary.ShortName); - writer.WriteStartArray("term"u8); + writer.WriteStartArray("alias"u8); - foreach(var termItem in glossary.Term.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(termItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Glossary for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in glossary.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in glossary.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(glossary.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in glossary.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in glossary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in glossary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in glossary.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(glossary.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(glossary.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(glossary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(glossary.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(glossary.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(glossary.ShortName); - writer.WriteStartArray("term"u8); + writer.WriteStartArray("definition"u8); - foreach(var termItem in glossary.Term.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(termItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Glossary for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in glossary.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in glossary.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(glossary.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in glossary.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in glossary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in glossary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in glossary.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(glossary.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(glossary.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(glossary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(glossary.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(glossary.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(glossary.ShortName); - writer.WriteStartArray("term"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var termItem in glossary.Term.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(termItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(glossary.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Glossary for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(glossary.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(glossary.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in glossary.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in glossary.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(glossary.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in glossary.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in glossary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in glossary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in glossary.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(glossary.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(glossary.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(glossary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - writer.WriteStringValue(glossary.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(glossary.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(glossary.ShortName); - writer.WriteStartArray("term"u8); - - foreach(var termItem in glossary.Term.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(termItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(glossary.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -429,53 +394,75 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) + writer.WritePropertyName("shortName"u8); + + if(value != null) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "term": + var allowedVersionsForTerm = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTerm.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("term"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListTerm) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var termItem in objectListTerm.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(termItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -483,249 +470,331 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the Glossary"); + } + } - writer.WriteStartArray("definition"u8); + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not Glossary glossary) + { + throw new ArgumentException("The thing shall be a Glossary", nameof(thing)); + } - if(value is IEnumerable objectListDefinition) + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Glossary since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Glossary for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in glossary.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in glossary.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(glossary.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var definitionItem in glossary.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in glossary.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(glossary.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(glossary.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(glossary.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(glossary.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(glossary.ShortName); + writer.WriteStartArray("term"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var termItem in glossary.Term.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(termItem); } - + writer.WriteEndArray(); break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Glossary for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in glossary.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var categoryItem in glossary.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(glossary.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in glossary.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in glossary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in glossary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in glossary.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(glossary.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else + writer.WriteBooleanValue(glossary.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(glossary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(glossary.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(glossary.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(glossary.ShortName); + writer.WriteStartArray("term"u8); + + foreach(var termItem in glossary.Term.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(termItem); } + writer.WriteEndArray(); break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Glossary for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in glossary.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in glossary.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(glossary.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in glossary.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in glossary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in glossary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in glossary.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(glossary.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(glossary.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(glossary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(glossary.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(glossary.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(glossary.ShortName); + writer.WriteStartArray("term"u8); + + foreach(var termItem in glossary.Term.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(termItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(glossary.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Glossary for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(glossary.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(glossary.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) + foreach(var aliasItem in glossary.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in glossary.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "term": - if(!AllowedVersionsPerProperty["term"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(glossary.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in glossary.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WriteStartArray("term"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListTerm) + foreach(var excludedDomainItem in glossary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var termItem in objectListTerm.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in glossary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in glossary.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(glossary.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(glossary.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(glossary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(glossary.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(glossary.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(glossary.ShortName); + writer.WriteStartArray("term"u8); + + foreach(var termItem in glossary.Term.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(termItem); } + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(glossary.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the Glossary"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "term", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/GoalSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/GoalSerializer.cs index 0fa9e943..6d418939 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/GoalSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/GoalSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,260 +49,6 @@ namespace CDP4JsonSerializer /// public class GoalSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Goal goal) - { - throw new ArgumentException("The thing shall be a Goal", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Goal since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Goal for Version 1.1.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in goal.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in goal.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(goal.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in goal.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in goal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in goal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in goal.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(goal.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(goal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(goal.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(goal.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(goal.ShortName); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Goal for Version 1.2.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in goal.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in goal.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(goal.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in goal.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in goal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in goal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in goal.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(goal.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(goal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(goal.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(goal.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(goal.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(goal.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Goal for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(goal.Actor.HasValue) - { - writer.WriteStringValue(goal.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in goal.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in goal.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(goal.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in goal.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in goal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in goal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in goal.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(goal.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(goal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(goal.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(goal.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(goal.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(goal.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -311,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -319,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -337,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + var allowedVersionsForAlias = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) { return; } @@ -355,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) { return; } @@ -373,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -391,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + var allowedVersionsForDefinition = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { return; } @@ -409,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -427,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -445,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + var allowedVersionsForHyperLink = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { return; } @@ -463,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -481,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -499,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -517,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -535,7 +361,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -553,7 +386,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -576,25 +415,240 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Goal goal) + { + throw new ArgumentException("The thing shall be a Goal", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Goal since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Goal for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in goal.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in goal.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(goal.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in goal.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in goal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in goal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in goal.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(goal.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(goal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(goal.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(goal.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(goal.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Goal for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in goal.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in goal.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(goal.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in goal.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in goal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in goal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in goal.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(goal.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(goal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(goal.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(goal.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(goal.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(goal.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Goal for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(goal.Actor.HasValue) + { + writer.WriteStringValue(goal.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in goal.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in goal.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(goal.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in goal.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in goal.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in goal.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in goal.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(goal.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(goal.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(goal.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(goal.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(goal.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(goal.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/HyperLinkSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/HyperLinkSerializer.cs index d8d7d103..13174fe2 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/HyperLinkSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/HyperLinkSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,173 +49,6 @@ namespace CDP4JsonSerializer /// public class HyperLinkSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not HyperLink hyperLink) - { - throw new ArgumentException("The thing shall be a HyperLink", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of HyperLink since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing HyperLink for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(hyperLink.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(hyperLink.Content); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(hyperLink.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(hyperLink.LanguageCode); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(hyperLink.RevisionNumber); - writer.WritePropertyName("uri"u8); - writer.WriteStringValue(hyperLink.Uri); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing HyperLink for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(hyperLink.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(hyperLink.Content); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in hyperLink.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in hyperLink.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(hyperLink.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(hyperLink.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(hyperLink.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(hyperLink.RevisionNumber); - writer.WritePropertyName("uri"u8); - writer.WriteStringValue(hyperLink.Uri); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing HyperLink for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(hyperLink.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(hyperLink.Content); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in hyperLink.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in hyperLink.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(hyperLink.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(hyperLink.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(hyperLink.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(hyperLink.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(hyperLink.ThingPreference); - writer.WritePropertyName("uri"u8); - writer.WriteStringValue(hyperLink.Uri); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing HyperLink for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(hyperLink.Actor.HasValue) - { - writer.WriteStringValue(hyperLink.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(hyperLink.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(hyperLink.Content); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in hyperLink.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in hyperLink.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(hyperLink.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(hyperLink.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(hyperLink.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(hyperLink.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(hyperLink.ThingPreference); - writer.WritePropertyName("uri"u8); - writer.WriteStringValue(hyperLink.Uri); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -224,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -232,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -250,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -268,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + var allowedVersionsForContent = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContent.Contains(requestedVersion)) { return; } @@ -286,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -304,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -322,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -340,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + var allowedVersionsForLanguageCode = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } @@ -358,7 +240,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -376,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -394,7 +291,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -412,7 +315,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "uri": - if(!AllowedVersionsPerProperty["uri"].Contains(requestedVersion)) + var allowedVersionsForUri = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUri.Contains(requestedVersion)) { return; } @@ -435,22 +346,165 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "uri", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not HyperLink hyperLink) + { + throw new ArgumentException("The thing shall be a HyperLink", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of HyperLink since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing HyperLink for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(hyperLink.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(hyperLink.Content); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(hyperLink.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(hyperLink.LanguageCode); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(hyperLink.RevisionNumber); + writer.WritePropertyName("uri"u8); + writer.WriteStringValue(hyperLink.Uri); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing HyperLink for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(hyperLink.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(hyperLink.Content); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in hyperLink.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in hyperLink.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(hyperLink.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(hyperLink.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(hyperLink.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(hyperLink.RevisionNumber); + writer.WritePropertyName("uri"u8); + writer.WriteStringValue(hyperLink.Uri); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing HyperLink for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(hyperLink.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(hyperLink.Content); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in hyperLink.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in hyperLink.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(hyperLink.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(hyperLink.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(hyperLink.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(hyperLink.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(hyperLink.ThingPreference); + writer.WritePropertyName("uri"u8); + writer.WriteStringValue(hyperLink.Uri); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing HyperLink for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(hyperLink.Actor.HasValue) + { + writer.WriteStringValue(hyperLink.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(hyperLink.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(hyperLink.Content); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in hyperLink.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in hyperLink.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(hyperLink.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(hyperLink.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(hyperLink.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(hyperLink.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(hyperLink.ThingPreference); + writer.WritePropertyName("uri"u8); + writer.WriteStringValue(hyperLink.Uri); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/IdCorrespondenceSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/IdCorrespondenceSerializer.cs index 2c602e0b..e5921d73 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/IdCorrespondenceSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/IdCorrespondenceSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,165 +49,6 @@ namespace CDP4JsonSerializer /// public class IdCorrespondenceSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not IdCorrespondence idCorrespondence) - { - throw new ArgumentException("The thing shall be a IdCorrespondence", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of IdCorrespondence since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing IdCorrespondence for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(idCorrespondence.ClassKind.ToString()); - writer.WritePropertyName("externalId"u8); - writer.WriteStringValue(idCorrespondence.ExternalId); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(idCorrespondence.Iid); - writer.WritePropertyName("internalThing"u8); - writer.WriteStringValue(idCorrespondence.InternalThing); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(idCorrespondence.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing IdCorrespondence for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(idCorrespondence.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in idCorrespondence.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in idCorrespondence.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("externalId"u8); - writer.WriteStringValue(idCorrespondence.ExternalId); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(idCorrespondence.Iid); - writer.WritePropertyName("internalThing"u8); - writer.WriteStringValue(idCorrespondence.InternalThing); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(idCorrespondence.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(idCorrespondence.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing IdCorrespondence for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(idCorrespondence.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in idCorrespondence.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in idCorrespondence.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("externalId"u8); - writer.WriteStringValue(idCorrespondence.ExternalId); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(idCorrespondence.Iid); - writer.WritePropertyName("internalThing"u8); - writer.WriteStringValue(idCorrespondence.InternalThing); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(idCorrespondence.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(idCorrespondence.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(idCorrespondence.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing IdCorrespondence for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(idCorrespondence.Actor.HasValue) - { - writer.WriteStringValue(idCorrespondence.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(idCorrespondence.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in idCorrespondence.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in idCorrespondence.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("externalId"u8); - writer.WriteStringValue(idCorrespondence.ExternalId); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(idCorrespondence.Iid); - writer.WritePropertyName("internalThing"u8); - writer.WriteStringValue(idCorrespondence.InternalThing); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(idCorrespondence.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(idCorrespondence.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(idCorrespondence.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -216,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -224,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -242,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -260,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -278,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -296,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "externalid": - if(!AllowedVersionsPerProperty["externalId"].Contains(requestedVersion)) + var allowedVersionsForExternalId = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExternalId.Contains(requestedVersion)) { return; } @@ -314,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -332,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "internalthing": - if(!AllowedVersionsPerProperty["internalThing"].Contains(requestedVersion)) + var allowedVersionsForInternalThing = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForInternalThing.Contains(requestedVersion)) { return; } @@ -350,7 +240,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -368,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -386,7 +291,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -409,21 +320,157 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "externalId", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "internalThing", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not IdCorrespondence idCorrespondence) + { + throw new ArgumentException("The thing shall be a IdCorrespondence", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of IdCorrespondence since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing IdCorrespondence for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(idCorrespondence.ClassKind.ToString()); + writer.WritePropertyName("externalId"u8); + writer.WriteStringValue(idCorrespondence.ExternalId); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(idCorrespondence.Iid); + writer.WritePropertyName("internalThing"u8); + writer.WriteStringValue(idCorrespondence.InternalThing); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(idCorrespondence.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing IdCorrespondence for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(idCorrespondence.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in idCorrespondence.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in idCorrespondence.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("externalId"u8); + writer.WriteStringValue(idCorrespondence.ExternalId); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(idCorrespondence.Iid); + writer.WritePropertyName("internalThing"u8); + writer.WriteStringValue(idCorrespondence.InternalThing); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(idCorrespondence.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(idCorrespondence.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing IdCorrespondence for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(idCorrespondence.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in idCorrespondence.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in idCorrespondence.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("externalId"u8); + writer.WriteStringValue(idCorrespondence.ExternalId); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(idCorrespondence.Iid); + writer.WritePropertyName("internalThing"u8); + writer.WriteStringValue(idCorrespondence.InternalThing); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(idCorrespondence.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(idCorrespondence.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(idCorrespondence.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing IdCorrespondence for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(idCorrespondence.Actor.HasValue) + { + writer.WriteStringValue(idCorrespondence.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(idCorrespondence.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in idCorrespondence.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in idCorrespondence.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("externalId"u8); + writer.WriteStringValue(idCorrespondence.ExternalId); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(idCorrespondence.Iid); + writer.WritePropertyName("internalThing"u8); + writer.WriteStringValue(idCorrespondence.InternalThing); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(idCorrespondence.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(idCorrespondence.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(idCorrespondence.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/IndependentParameterTypeAssignmentSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/IndependentParameterTypeAssignmentSerializer.cs index 0ba05cad..ef20fd8f 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/IndependentParameterTypeAssignmentSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/IndependentParameterTypeAssignmentSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,137 +49,6 @@ namespace CDP4JsonSerializer /// public class IndependentParameterTypeAssignmentSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not IndependentParameterTypeAssignment independentParameterTypeAssignment) - { - throw new ArgumentException("The thing shall be a IndependentParameterTypeAssignment", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.2.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of IndependentParameterTypeAssignment since Version is below 1.2.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing IndependentParameterTypeAssignment for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(independentParameterTypeAssignment.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in independentParameterTypeAssignment.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in independentParameterTypeAssignment.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(independentParameterTypeAssignment.Iid); - writer.WritePropertyName("measurementScale"u8); - - if(independentParameterTypeAssignment.MeasurementScale.HasValue) - { - writer.WriteStringValue(independentParameterTypeAssignment.MeasurementScale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(independentParameterTypeAssignment.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(independentParameterTypeAssignment.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(independentParameterTypeAssignment.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(independentParameterTypeAssignment.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing IndependentParameterTypeAssignment for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(independentParameterTypeAssignment.Actor.HasValue) - { - writer.WriteStringValue(independentParameterTypeAssignment.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(independentParameterTypeAssignment.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in independentParameterTypeAssignment.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in independentParameterTypeAssignment.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(independentParameterTypeAssignment.Iid); - writer.WritePropertyName("measurementScale"u8); - - if(independentParameterTypeAssignment.MeasurementScale.HasValue) - { - writer.WriteStringValue(independentParameterTypeAssignment.MeasurementScale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(independentParameterTypeAssignment.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(independentParameterTypeAssignment.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(independentParameterTypeAssignment.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(independentParameterTypeAssignment.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -188,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -196,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -214,7 +86,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -232,7 +110,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -250,7 +135,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -268,7 +160,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -286,7 +184,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "measurementscale": - if(!AllowedVersionsPerProperty["measurementScale"].Contains(requestedVersion)) + var allowedVersionsForMeasurementScale = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMeasurementScale.Contains(requestedVersion)) { return; } @@ -304,7 +208,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -322,7 +233,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + var allowedVersionsForParameterType = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterType.Contains(requestedVersion)) { return; } @@ -340,7 +257,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -358,7 +281,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -381,21 +310,131 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.2.0", "1.3.0" }}, - { "measurementScale", new []{ "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not IndependentParameterTypeAssignment independentParameterTypeAssignment) + { + throw new ArgumentException("The thing shall be a IndependentParameterTypeAssignment", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.2.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of IndependentParameterTypeAssignment since Version is below 1.2.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing IndependentParameterTypeAssignment for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(independentParameterTypeAssignment.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in independentParameterTypeAssignment.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in independentParameterTypeAssignment.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(independentParameterTypeAssignment.Iid); + writer.WritePropertyName("measurementScale"u8); + + if(independentParameterTypeAssignment.MeasurementScale.HasValue) + { + writer.WriteStringValue(independentParameterTypeAssignment.MeasurementScale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(independentParameterTypeAssignment.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(independentParameterTypeAssignment.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(independentParameterTypeAssignment.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(independentParameterTypeAssignment.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing IndependentParameterTypeAssignment for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(independentParameterTypeAssignment.Actor.HasValue) + { + writer.WriteStringValue(independentParameterTypeAssignment.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(independentParameterTypeAssignment.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in independentParameterTypeAssignment.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in independentParameterTypeAssignment.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(independentParameterTypeAssignment.Iid); + writer.WritePropertyName("measurementScale"u8); + + if(independentParameterTypeAssignment.MeasurementScale.HasValue) + { + writer.WriteStringValue(independentParameterTypeAssignment.MeasurementScale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(independentParameterTypeAssignment.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(independentParameterTypeAssignment.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(independentParameterTypeAssignment.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(independentParameterTypeAssignment.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/IntervalScaleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/IntervalScaleSerializer.cs index 6fa8d528..3dfd5bc2 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/IntervalScaleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/IntervalScaleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,441 +50,292 @@ namespace CDP4JsonSerializer public class IntervalScaleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not IntervalScale intervalScale) - { - throw new ArgumentException("The thing shall be a IntervalScale", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of IntervalScale since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing IntervalScale for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in intervalScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(intervalScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in intervalScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in intervalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(intervalScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(intervalScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(intervalScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(intervalScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var mappingToReferenceScaleItem in intervalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(mappingToReferenceScaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(intervalScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(intervalScale.MinimumPermissibleValue); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(intervalScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(intervalScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(intervalScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(intervalScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(intervalScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(intervalScale.ShortName); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(intervalScale.Unit); - writer.WriteStartArray("valueDefinition"u8); + writer.WriteStartArray("alias"u8); - foreach(var valueDefinitionItem in intervalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(valueDefinitionItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing IntervalScale for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in intervalScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(intervalScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in intervalScale.Definition.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in intervalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in intervalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in intervalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(intervalScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(intervalScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(intervalScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(intervalScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var mappingToReferenceScaleItem in intervalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(mappingToReferenceScaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(intervalScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(intervalScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(intervalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(intervalScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(intervalScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(intervalScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(intervalScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(intervalScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(intervalScale.ShortName); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(intervalScale.Unit); - writer.WriteStartArray("valueDefinition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var valueDefinitionItem in intervalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(valueDefinitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing IntervalScale for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in intervalScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(intervalScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var definitionItem in intervalScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(definitionItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in intervalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var excludedPersonItem in intervalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(excludedPersonItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in intervalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(intervalScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(intervalScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(intervalScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(intervalScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); - - foreach(var mappingToReferenceScaleItem in intervalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(mappingToReferenceScaleItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(intervalScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(intervalScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(intervalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(intervalScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(intervalScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(intervalScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(intervalScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(intervalScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(intervalScale.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(intervalScale.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(intervalScale.Unit); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in intervalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueDefinitionItem); - } - - writer.WriteEndArray(); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing IntervalScale for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(intervalScale.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(intervalScale.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in intervalScale.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(intervalScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in intervalScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in intervalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in intervalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "ismaximuminclusive": + var allowedVersionsForIsMaximumInclusive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in intervalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsMaximumInclusive.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(intervalScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(intervalScale.IsDeprecated); writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(intervalScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(intervalScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); - - foreach(var mappingToReferenceScaleItem in intervalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(mappingToReferenceScaleItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(intervalScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(intervalScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(intervalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(intervalScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(intervalScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(intervalScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(intervalScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(intervalScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(intervalScale.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(intervalScale.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(intervalScale.Unit); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in intervalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(valueDefinitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "isminimuminclusive": + var allowedVersionsForIsMinimumInclusive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForIsMinimumInclusive.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("isMinimumInclusive"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteBooleanValue((bool)value); } else { @@ -493,35 +343,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "mappingtoreferencescale": + var allowedVersionsForMappingToReferenceScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMappingToReferenceScale.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("mappingToReferenceScale"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListMappingToReferenceScale) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var mappingToReferenceScaleItem in objectListMappingToReferenceScale.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteStringValue(mappingToReferenceScaleItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "maximumpermissiblevalue": + var allowedVersionsForMaximumPermissibleValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMaximumPermissibleValue.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("maximumPermissibleValue"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -529,89 +395,50 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "minimumpermissiblevalue": + var allowedVersionsForMinimumPermissibleValue = new List { - return; - } - - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForMinimumPermissibleValue.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } + writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List { - return; - } - - writer.WriteStartArray("hyperLink"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -619,17 +446,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isDeprecated"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -637,17 +472,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "ismaximuminclusive": - if(!AllowedVersionsPerProperty["isMaximumInclusive"].Contains(requestedVersion)) + case "negativevalueconnotation": + var allowedVersionsForNegativeValueConnotation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNegativeValueConnotation.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isMaximumInclusive"u8); + writer.WritePropertyName("negativeValueConnotation"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -655,17 +498,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isminimuminclusive": - if(!AllowedVersionsPerProperty["isMinimumInclusive"].Contains(requestedVersion)) + case "numberset": + var allowedVersionsForNumberSet = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNumberSet.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isMinimumInclusive"u8); + writer.WritePropertyName("numberSet"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(((NumberSetKind)value).ToString()); } else { @@ -673,31 +524,21 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "mappingtoreferencescale": - if(!AllowedVersionsPerProperty["mappingToReferenceScale"].Contains(requestedVersion)) + case "positivevalueconnotation": + var allowedVersionsForPositiveValueConnotation = new List { - return; - } - - writer.WriteStartArray("mappingToReferenceScale"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListMappingToReferenceScale) - { - foreach(var mappingToReferenceScaleItem in objectListMappingToReferenceScale.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(mappingToReferenceScaleItem); - } - } - - writer.WriteEndArray(); - break; - case "maximumpermissiblevalue": - if(!AllowedVersionsPerProperty["maximumPermissibleValue"].Contains(requestedVersion)) + if(!allowedVersionsForPositiveValueConnotation.Contains(requestedVersion)) { return; } - writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WritePropertyName("positiveValueConnotation"u8); if(value != null) { @@ -709,17 +550,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "minimumpermissiblevalue": - if(!AllowedVersionsPerProperty["minimumPermissibleValue"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue((int)value); } else { @@ -727,17 +576,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((string)value); } else { @@ -745,13 +602,19 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("name"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { @@ -763,17 +626,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "negativevalueconnotation": - if(!AllowedVersionsPerProperty["negativeValueConnotation"].Contains(requestedVersion)) + case "unit": + var allowedVersionsForUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUnit.Contains(requestedVersion)) { return; } - writer.WritePropertyName("negativeValueConnotation"u8); + writer.WritePropertyName("unit"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue((Guid)value); } else { @@ -781,167 +652,421 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "numberset": - if(!AllowedVersionsPerProperty["numberSet"].Contains(requestedVersion)) + case "valuedefinition": + var allowedVersionsForValueDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueDefinition.Contains(requestedVersion)) { return; } - writer.WritePropertyName("numberSet"u8); + writer.WriteStartArray("valueDefinition"u8); + + if(value is IEnumerable objectListValueDefinition) + { + foreach(var valueDefinitionItem in objectListValueDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueDefinitionItem); + } + } - if(value != null) + writer.WriteEndArray(); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the IntervalScale"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not IntervalScale intervalScale) + { + throw new ArgumentException("The thing shall be a IntervalScale", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of IntervalScale since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing IntervalScale for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in intervalScale.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((NumberSetKind)value).ToString()); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(intervalScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in intervalScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "positivevalueconnotation": - if(!AllowedVersionsPerProperty["positiveValueConnotation"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in intervalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("positiveValueConnotation"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(intervalScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(intervalScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(intervalScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(intervalScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in intervalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(mappingToReferenceScaleItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(intervalScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(intervalScale.MinimumPermissibleValue); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(intervalScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(intervalScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(intervalScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(intervalScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(intervalScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(intervalScale.ShortName); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(intervalScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in intervalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(valueDefinitionItem); } + writer.WriteEndArray(); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing IntervalScale for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in intervalScale.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(intervalScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in intervalScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in intervalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in intervalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in intervalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(intervalScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(intervalScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(intervalScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(intervalScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in intervalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(mappingToReferenceScaleItem); } + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(intervalScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(intervalScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(intervalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(intervalScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(intervalScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(intervalScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(intervalScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(intervalScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(intervalScale.ShortName); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(intervalScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in intervalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueDefinitionItem); + } + + writer.WriteEndArray(); break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing IntervalScale for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in intervalScale.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(intervalScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in intervalScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in intervalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "unit": - if(!AllowedVersionsPerProperty["unit"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in intervalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in intervalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(intervalScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(intervalScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(intervalScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(intervalScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in intervalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(mappingToReferenceScaleItem); } + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(intervalScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(intervalScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(intervalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(intervalScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(intervalScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(intervalScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(intervalScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(intervalScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(intervalScale.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(intervalScale.ThingPreference); writer.WritePropertyName("unit"u8); - - if(value != null) + writer.WriteStringValue(intervalScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in intervalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(valueDefinitionItem); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing IntervalScale for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(intervalScale.Actor.HasValue) + { + writer.WriteStringValue(intervalScale.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "valuedefinition": - if(!AllowedVersionsPerProperty["valueDefinition"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in intervalScale.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(intervalScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in intervalScale.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in intervalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in intervalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in intervalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(intervalScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(intervalScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(intervalScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(intervalScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in intervalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(mappingToReferenceScaleItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(intervalScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(intervalScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(intervalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(intervalScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(intervalScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(intervalScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(intervalScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(intervalScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(intervalScale.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(intervalScale.ThingPreference); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(intervalScale.Unit); writer.WriteStartArray("valueDefinition"u8); - if(value is IEnumerable objectListValueDefinition) + foreach(var valueDefinitionItem in intervalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - foreach(var valueDefinitionItem in objectListValueDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueDefinitionItem); - } + writer.WriteStringValue(valueDefinitionItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the IntervalScale"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isMaximumInclusive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isMinimumInclusive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "mappingToReferenceScale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "maximumPermissibleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "minimumPermissibleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "negativeValueConnotation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "numberSet", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "positiveValueConnotation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "unit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "valueDefinition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/IterationSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/IterationSerializer.cs index 09ac4f3a..618c3355 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/IterationSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/IterationSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,613 +50,789 @@ namespace CDP4JsonSerializer public class IterationSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not Iteration iteration) - { - throw new ArgumentException("The thing shall be a Iteration", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Iteration since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Iteration for Version 1.0.0"); - writer.WriteStartArray("actualFiniteStateList"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var actualFiniteStateListItem in iteration.ActualFiniteStateList.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(actualFiniteStateListItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(iteration.ClassKind.ToString()); - writer.WritePropertyName("defaultOption"u8); - - if(iteration.DefaultOption.HasValue) + if(value != null) { - writer.WriteStringValue(iteration.DefaultOption.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("domainFileStore"u8); - - foreach(var domainFileStoreItem in iteration.DomainFileStore.OrderBy(x => x, this.GuidComparer)) + break; + case "actualfinitestatelist": + var allowedVersionsForActualFiniteStateList = new List { - writer.WriteStringValue(domainFileStoreItem); - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WriteStartArray("element"u8); - - foreach(var elementItem in iteration.Element.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActualFiniteStateList.Contains(requestedVersion)) { - writer.WriteStringValue(elementItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("externalIdentifierMap"u8); + writer.WriteStartArray("actualFiniteStateList"u8); - foreach(var externalIdentifierMapItem in iteration.ExternalIdentifierMap.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListActualFiniteStateList) { - writer.WriteStringValue(externalIdentifierMapItem); + foreach(var actualFiniteStateListItem in objectListActualFiniteStateList.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(actualFiniteStateListItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(iteration.Iid); - writer.WritePropertyName("iterationSetup"u8); - writer.WriteStringValue(iteration.IterationSetup); - writer.WriteStartArray("option"u8); - - foreach(var optionItem in iteration.Option.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(optionItem); - } - writer.WriteEndArray(); - - writer.WriteStartArray("possibleFiniteStateList"u8); - - foreach(var possibleFiniteStateListItem in iteration.PossibleFiniteStateList.OrderBy(x => x, this.GuidComparer)) + break; + case "classkind": + var allowedVersionsForClassKind = new List { - writer.WriteStringValue(possibleFiniteStateListItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("publication"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var publicationItem in iteration.Publication.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(publicationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("relationship"u8); - - foreach(var relationshipItem in iteration.Relationship.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(relationshipItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("requirementsSpecification"u8); - - foreach(var requirementsSpecificationItem in iteration.RequirementsSpecification.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(requirementsSpecificationItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(iteration.RevisionNumber); - writer.WriteStartArray("ruleVerificationList"u8); + break; + case "defaultoption": + var allowedVersionsForDefaultOption = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var ruleVerificationListItem in iteration.RuleVerificationList.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefaultOption.Contains(requestedVersion)) { - writer.WriteStringValue(ruleVerificationListItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("defaultOption"u8); - writer.WritePropertyName("sourceIterationIid"u8); - - if(iteration.SourceIterationIid.HasValue) + if(value != null) { - writer.WriteStringValue(iteration.SourceIterationIid.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("topElement"u8); + break; + case "diagramcanvas": + var allowedVersionsForDiagramCanvas = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(iteration.TopElement.HasValue) + if(!allowedVersionsForDiagramCanvas.Contains(requestedVersion)) { - writer.WriteStringValue(iteration.TopElement.Value); + return; } - else + + writer.WriteStartArray("diagramCanvas"u8); + + if(value is IEnumerable objectListDiagramCanvas) { - writer.WriteNullValue(); + foreach(var diagramCanvasItem in objectListDiagramCanvas.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(diagramCanvasItem); + } } - + + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Iteration for Version 1.1.0"); - writer.WriteStartArray("actualFiniteStateList"u8); + case "domainfilestore": + var allowedVersionsForDomainFileStore = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var actualFiniteStateListItem in iteration.ActualFiniteStateList.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDomainFileStore.Contains(requestedVersion)) { - writer.WriteStringValue(actualFiniteStateListItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(iteration.ClassKind.ToString()); - writer.WritePropertyName("defaultOption"u8); + writer.WriteStartArray("domainFileStore"u8); - if(iteration.DefaultOption.HasValue) + if(value is IEnumerable objectListDomainFileStore) { - writer.WriteStringValue(iteration.DefaultOption.Value); + foreach(var domainFileStoreItem in objectListDomainFileStore.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainFileStoreItem); + } } - else + + writer.WriteEndArray(); + break; + case "element": + var allowedVersionsForElement = new List { - writer.WriteNullValue(); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForElement.Contains(requestedVersion)) + { + return; } - writer.WriteStartArray("diagramCanvas"u8); + writer.WriteStartArray("element"u8); - foreach(var diagramCanvasItem in iteration.DiagramCanvas.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListElement) { - writer.WriteStringValue(diagramCanvasItem); + foreach(var elementItem in objectListElement.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(elementItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("domainFileStore"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var domainFileStoreItem in iteration.DomainFileStore.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(domainFileStoreItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("element"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var elementItem in iteration.Element.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(elementItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in iteration.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in iteration.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("externalIdentifierMap"u8); + writer.WriteEndArray(); + break; + case "externalidentifiermap": + var allowedVersionsForExternalIdentifierMap = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var externalIdentifierMapItem in iteration.ExternalIdentifierMap.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExternalIdentifierMap.Contains(requestedVersion)) { - writer.WriteStringValue(externalIdentifierMapItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("externalIdentifierMap"u8); + + if(value is IEnumerable objectListExternalIdentifierMap) + { + foreach(var externalIdentifierMapItem in objectListExternalIdentifierMap.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(externalIdentifierMapItem); + } + } - writer.WriteStartArray("goal"u8); + writer.WriteEndArray(); + break; + case "goal": + var allowedVersionsForGoal = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var goalItem in iteration.Goal.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForGoal.Contains(requestedVersion)) { - writer.WriteStringValue(goalItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(iteration.Iid); - writer.WritePropertyName("iterationSetup"u8); - writer.WriteStringValue(iteration.IterationSetup); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(iteration.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("option"u8); + writer.WriteStartArray("goal"u8); - foreach(var optionItem in iteration.Option.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListGoal) { - writer.WriteOrderedItem(optionItem); + foreach(var goalItem in objectListGoal.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(goalItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("possibleFiniteStateList"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var possibleFiniteStateListItem in iteration.PossibleFiniteStateList.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(possibleFiniteStateListItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WriteStartArray("publication"u8); - - foreach(var publicationItem in iteration.Publication.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(publicationItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("relationship"u8); - - foreach(var relationshipItem in iteration.Relationship.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(relationshipItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("requirementsSpecification"u8); + break; + case "iterationsetup": + var allowedVersionsForIterationSetup = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var requirementsSpecificationItem in iteration.RequirementsSpecification.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIterationSetup.Contains(requestedVersion)) { - writer.WriteStringValue(requirementsSpecificationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iterationSetup"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(iteration.RevisionNumber); - writer.WriteStartArray("ruleVerificationList"u8); - - foreach(var ruleVerificationListItem in iteration.RuleVerificationList.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(ruleVerificationListItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("sharedDiagramStyle"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var sharedDiagramStyleItem in iteration.SharedDiagramStyle.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(sharedDiagramStyleItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WritePropertyName("sourceIterationIid"u8); - - if(iteration.SourceIterationIid.HasValue) + if(value != null) { - writer.WriteStringValue(iteration.SourceIterationIid.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("stakeholder"u8); + break; + case "option": + var allowedVersionsForOption = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var stakeholderItem in iteration.Stakeholder.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForOption.Contains(requestedVersion)) { - writer.WriteStringValue(stakeholderItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("stakeholderValue"u8); + writer.WriteStartArray("option"u8); - foreach(var stakeholderValueItem in iteration.StakeholderValue.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListOption) { - writer.WriteStringValue(stakeholderValueItem); + foreach(var optionItem in objectListOption.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(optionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("stakeholderValueMap"u8); + writer.WriteEndArray(); + break; + case "possiblefinitestatelist": + var allowedVersionsForPossibleFiniteStateList = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var stakeholderValueMapItem in iteration.StakeholderValueMap.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForPossibleFiniteStateList.Contains(requestedVersion)) { - writer.WriteStringValue(stakeholderValueMapItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("topElement"u8); + writer.WriteStartArray("possibleFiniteStateList"u8); - if(iteration.TopElement.HasValue) + if(value is IEnumerable objectListPossibleFiniteStateList) { - writer.WriteStringValue(iteration.TopElement.Value); + foreach(var possibleFiniteStateListItem in objectListPossibleFiniteStateList.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(possibleFiniteStateListItem); + } } - else + + writer.WriteEndArray(); + break; + case "publication": + var allowedVersionsForPublication = new List { - writer.WriteNullValue(); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPublication.Contains(requestedVersion)) + { + return; } - writer.WriteStartArray("valueGroup"u8); + writer.WriteStartArray("publication"u8); - foreach(var valueGroupItem in iteration.ValueGroup.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListPublication) { - writer.WriteStringValue(valueGroupItem); + foreach(var publicationItem in objectListPublication.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(publicationItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Iteration for Version 1.2.0"); - writer.WriteStartArray("actualFiniteStateList"u8); + case "relationship": + var allowedVersionsForRelationship = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var actualFiniteStateListItem in iteration.ActualFiniteStateList.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRelationship.Contains(requestedVersion)) { - writer.WriteStringValue(actualFiniteStateListItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(iteration.ClassKind.ToString()); - writer.WritePropertyName("defaultOption"u8); + writer.WriteStartArray("relationship"u8); - if(iteration.DefaultOption.HasValue) + if(value is IEnumerable objectListRelationship) { - writer.WriteStringValue(iteration.DefaultOption.Value); + foreach(var relationshipItem in objectListRelationship.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relationshipItem); + } } - else + + writer.WriteEndArray(); + break; + case "requirementsspecification": + var allowedVersionsForRequirementsSpecification = new List { - writer.WriteNullValue(); - } - - writer.WriteStartArray("diagramCanvas"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var diagramCanvasItem in iteration.DiagramCanvas.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRequirementsSpecification.Contains(requestedVersion)) { - writer.WriteStringValue(diagramCanvasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("domainFileStore"u8); + writer.WriteStartArray("requirementsSpecification"u8); - foreach(var domainFileStoreItem in iteration.DomainFileStore.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListRequirementsSpecification) { - writer.WriteStringValue(domainFileStoreItem); + foreach(var requirementsSpecificationItem in objectListRequirementsSpecification.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(requirementsSpecificationItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("element"u8); + writer.WriteEndArray(); + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var elementItem in iteration.Element.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - writer.WriteStringValue(elementItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in iteration.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNumberValue((int)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in iteration.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("externalIdentifierMap"u8); + break; + case "ruleverificationlist": + var allowedVersionsForRuleVerificationList = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var externalIdentifierMapItem in iteration.ExternalIdentifierMap.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRuleVerificationList.Contains(requestedVersion)) { - writer.WriteStringValue(externalIdentifierMapItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("goal"u8); + writer.WriteStartArray("ruleVerificationList"u8); - foreach(var goalItem in iteration.Goal.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListRuleVerificationList) { - writer.WriteStringValue(goalItem); + foreach(var ruleVerificationListItem in objectListRuleVerificationList.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(ruleVerificationListItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(iteration.Iid); - writer.WritePropertyName("iterationSetup"u8); - writer.WriteStringValue(iteration.IterationSetup); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(iteration.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("option"u8); + writer.WriteEndArray(); + break; + case "shareddiagramstyle": + var allowedVersionsForSharedDiagramStyle = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var optionItem in iteration.Option.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForSharedDiagramStyle.Contains(requestedVersion)) { - writer.WriteOrderedItem(optionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("possibleFiniteStateList"u8); + writer.WriteStartArray("sharedDiagramStyle"u8); - foreach(var possibleFiniteStateListItem in iteration.PossibleFiniteStateList.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListSharedDiagramStyle) { - writer.WriteStringValue(possibleFiniteStateListItem); + foreach(var sharedDiagramStyleItem in objectListSharedDiagramStyle.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sharedDiagramStyleItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("publication"u8); + writer.WriteEndArray(); + break; + case "sourceiterationiid": + var allowedVersionsForSourceIterationIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var publicationItem in iteration.Publication.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForSourceIterationIid.Contains(requestedVersion)) { - writer.WriteStringValue(publicationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("sourceIterationIid"u8); - writer.WriteStartArray("relationship"u8); - - foreach(var relationshipItem in iteration.Relationship.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(relationshipItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("requirementsSpecification"u8); + break; + case "stakeholder": + var allowedVersionsForStakeholder = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var requirementsSpecificationItem in iteration.RequirementsSpecification.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForStakeholder.Contains(requestedVersion)) { - writer.WriteStringValue(requirementsSpecificationItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(iteration.RevisionNumber); - writer.WriteStartArray("ruleVerificationList"u8); + writer.WriteStartArray("stakeholder"u8); - foreach(var ruleVerificationListItem in iteration.RuleVerificationList.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListStakeholder) { - writer.WriteStringValue(ruleVerificationListItem); + foreach(var stakeholderItem in objectListStakeholder.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(stakeholderItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("sharedDiagramStyle"u8); + writer.WriteEndArray(); + break; + case "stakeholdervalue": + var allowedVersionsForStakeholderValue = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var sharedDiagramStyleItem in iteration.SharedDiagramStyle.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForStakeholderValue.Contains(requestedVersion)) { - writer.WriteStringValue(sharedDiagramStyleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("sourceIterationIid"u8); + writer.WriteStartArray("stakeholderValue"u8); - if(iteration.SourceIterationIid.HasValue) + if(value is IEnumerable objectListStakeholderValue) { - writer.WriteStringValue(iteration.SourceIterationIid.Value); + foreach(var stakeholderValueItem in objectListStakeholderValue.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(stakeholderValueItem); + } } - else + + writer.WriteEndArray(); + break; + case "stakeholdervaluemap": + var allowedVersionsForStakeholderValueMap = new List { - writer.WriteNullValue(); - } - - writer.WriteStartArray("stakeholder"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var stakeholderItem in iteration.Stakeholder.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForStakeholderValueMap.Contains(requestedVersion)) { - writer.WriteStringValue(stakeholderItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("stakeholderValue"u8); + writer.WriteStartArray("stakeholderValueMap"u8); - foreach(var stakeholderValueItem in iteration.StakeholderValue.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListStakeholderValueMap) { - writer.WriteStringValue(stakeholderValueItem); + foreach(var stakeholderValueMapItem in objectListStakeholderValueMap.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(stakeholderValueMapItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("stakeholderValueMap"u8); + writer.WriteEndArray(); + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; - foreach(var stakeholderValueMapItem in iteration.StakeholderValueMap.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { - writer.WriteStringValue(stakeholderValueMapItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(iteration.ThingPreference); - writer.WritePropertyName("topElement"u8); - - if(iteration.TopElement.HasValue) + + if(value != null) { - writer.WriteStringValue(iteration.TopElement.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("valueGroup"u8); + break; + case "topelement": + var allowedVersionsForTopElement = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var valueGroupItem in iteration.ValueGroup.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForTopElement.Contains(requestedVersion)) { - writer.WriteStringValue(valueGroupItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("topElement"u8); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Iteration for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(iteration.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(iteration.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } + break; + case "valuegroup": + var allowedVersionsForValueGroup = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueGroup.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("valueGroup"u8); + + if(value is IEnumerable objectListValueGroup) + { + foreach(var valueGroupItem in objectListValueGroup.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueGroupItem); + } + } + + writer.WriteEndArray(); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the Iteration"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not Iteration iteration) + { + throw new ArgumentException("The thing shall be a Iteration", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Iteration since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Iteration for Version 1.0.0"); writer.WriteStartArray("actualFiniteStateList"u8); foreach(var actualFiniteStateListItem in iteration.ActualFiniteStateList.OrderBy(x => x, this.GuidComparer)) @@ -666,7 +841,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(iteration.ClassKind.ToString()); writer.WritePropertyName("defaultOption"u8); @@ -680,15 +854,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNullValue(); } - writer.WriteStartArray("diagramCanvas"u8); - - foreach(var diagramCanvasItem in iteration.DiagramCanvas.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(diagramCanvasItem); - } - - writer.WriteEndArray(); - writer.WriteStartArray("domainFileStore"u8); foreach(var domainFileStoreItem in iteration.DomainFileStore.OrderBy(x => x, this.GuidComparer)) @@ -697,7 +862,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("element"u8); foreach(var elementItem in iteration.Element.OrderBy(x => x, this.GuidComparer)) @@ -706,25 +870,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in iteration.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in iteration.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - writer.WriteStartArray("externalIdentifierMap"u8); foreach(var externalIdentifierMapItem in iteration.ExternalIdentifierMap.OrderBy(x => x, this.GuidComparer)) @@ -733,22 +878,10 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WriteStartArray("goal"u8); - - foreach(var goalItem in iteration.Goal.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(goalItem); - } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(iteration.Iid); writer.WritePropertyName("iterationSetup"u8); writer.WriteStringValue(iteration.IterationSetup); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(iteration.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WriteStartArray("option"u8); foreach(var optionItem in iteration.Option.OrderBy(x => x, this.OrderedItemComparer)) @@ -757,7 +890,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("possibleFiniteStateList"u8); foreach(var possibleFiniteStateListItem in iteration.PossibleFiniteStateList.OrderBy(x => x, this.GuidComparer)) @@ -766,7 +898,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("publication"u8); foreach(var publicationItem in iteration.Publication.OrderBy(x => x, this.GuidComparer)) @@ -775,7 +906,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("relationship"u8); foreach(var relationshipItem in iteration.Relationship.OrderBy(x => x, this.GuidComparer)) @@ -784,7 +914,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("requirementsSpecification"u8); foreach(var requirementsSpecificationItem in iteration.RequirementsSpecification.OrderBy(x => x, this.GuidComparer)) @@ -793,7 +922,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(iteration.RevisionNumber); writer.WriteStartArray("ruleVerificationList"u8); @@ -804,16 +932,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WriteStartArray("sharedDiagramStyle"u8); - - foreach(var sharedDiagramStyleItem in iteration.SharedDiagramStyle.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sharedDiagramStyleItem); - } - - writer.WriteEndArray(); - writer.WritePropertyName("sourceIterationIid"u8); if(iteration.SourceIterationIid.HasValue) @@ -825,639 +943,633 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNullValue(); } - writer.WriteStartArray("stakeholder"u8); + writer.WritePropertyName("topElement"u8); - foreach(var stakeholderItem in iteration.Stakeholder.OrderBy(x => x, this.GuidComparer)) + if(iteration.TopElement.HasValue) { - writer.WriteStringValue(stakeholderItem); + writer.WriteStringValue(iteration.TopElement.Value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("stakeholderValue"u8); - - foreach(var stakeholderValueItem in iteration.StakeholderValue.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(stakeholderValueItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("stakeholderValueMap"u8); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Iteration for Version 1.1.0"); + writer.WriteStartArray("actualFiniteStateList"u8); - foreach(var stakeholderValueMapItem in iteration.StakeholderValueMap.OrderBy(x => x, this.GuidComparer)) + foreach(var actualFiniteStateListItem in iteration.ActualFiniteStateList.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(stakeholderValueMapItem); + writer.WriteStringValue(actualFiniteStateListItem); } writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(iteration.ThingPreference); - writer.WritePropertyName("topElement"u8); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(iteration.ClassKind.ToString()); + writer.WritePropertyName("defaultOption"u8); - if(iteration.TopElement.HasValue) + if(iteration.DefaultOption.HasValue) { - writer.WriteStringValue(iteration.TopElement.Value); + writer.WriteStringValue(iteration.DefaultOption.Value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("valueGroup"u8); + writer.WriteStartArray("diagramCanvas"u8); - foreach(var valueGroupItem in iteration.ValueGroup.OrderBy(x => x, this.GuidComparer)) + foreach(var diagramCanvasItem in iteration.DiagramCanvas.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(valueGroupItem); + writer.WriteStringValue(diagramCanvasItem); } writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } + writer.WriteStartArray("domainFileStore"u8); - writer.WriteEndObject(); - } + foreach(var domainFileStoreItem in iteration.DomainFileStore.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainFileStoreItem); + } - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + writer.WriteEndArray(); + writer.WriteStartArray("element"u8); - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + foreach(var elementItem in iteration.Element.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(elementItem); } - writer.WritePropertyName("actor"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in iteration.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in iteration.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "actualfinitestatelist": - if(!AllowedVersionsPerProperty["actualFiniteStateList"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("externalIdentifierMap"u8); + + foreach(var externalIdentifierMapItem in iteration.ExternalIdentifierMap.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(externalIdentifierMapItem); } - writer.WriteStartArray("actualFiniteStateList"u8); + writer.WriteEndArray(); + writer.WriteStartArray("goal"u8); - if(value is IEnumerable objectListActualFiniteStateList) + foreach(var goalItem in iteration.Goal.OrderBy(x => x, this.GuidComparer)) { - foreach(var actualFiniteStateListItem in objectListActualFiniteStateList.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(actualFiniteStateListItem); - } + writer.WriteStringValue(goalItem); } - + writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(iteration.Iid); + writer.WritePropertyName("iterationSetup"u8); + writer.WriteStringValue(iteration.IterationSetup); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(iteration.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("option"u8); + + foreach(var optionItem in iteration.Option.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(optionItem); } - writer.WritePropertyName("classKind"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("possibleFiniteStateList"u8); + + foreach(var possibleFiniteStateListItem in iteration.PossibleFiniteStateList.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(possibleFiniteStateListItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("publication"u8); + + foreach(var publicationItem in iteration.Publication.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(publicationItem); } - break; - case "defaultoption": - if(!AllowedVersionsPerProperty["defaultOption"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("relationship"u8); + + foreach(var relationshipItem in iteration.Relationship.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relationshipItem); } - writer.WritePropertyName("defaultOption"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("requirementsSpecification"u8); + + foreach(var requirementsSpecificationItem in iteration.RequirementsSpecification.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(requirementsSpecificationItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(iteration.RevisionNumber); + writer.WriteStartArray("ruleVerificationList"u8); + + foreach(var ruleVerificationListItem in iteration.RuleVerificationList.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(ruleVerificationListItem); } - break; - case "diagramcanvas": - if(!AllowedVersionsPerProperty["diagramCanvas"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("sharedDiagramStyle"u8); + + foreach(var sharedDiagramStyleItem in iteration.SharedDiagramStyle.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(sharedDiagramStyleItem); } - writer.WriteStartArray("diagramCanvas"u8); + writer.WriteEndArray(); + writer.WritePropertyName("sourceIterationIid"u8); - if(value is IEnumerable objectListDiagramCanvas) + if(iteration.SourceIterationIid.HasValue) { - foreach(var diagramCanvasItem in objectListDiagramCanvas.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(diagramCanvasItem); - } + writer.WriteStringValue(iteration.SourceIterationIid.Value); } - - writer.WriteEndArray(); - break; - case "domainfilestore": - if(!AllowedVersionsPerProperty["domainFileStore"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("domainFileStore"u8); + writer.WriteStartArray("stakeholder"u8); - if(value is IEnumerable objectListDomainFileStore) + foreach(var stakeholderItem in iteration.Stakeholder.OrderBy(x => x, this.GuidComparer)) { - foreach(var domainFileStoreItem in objectListDomainFileStore.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainFileStoreItem); - } + writer.WriteStringValue(stakeholderItem); } - + writer.WriteEndArray(); - break; - case "element": - if(!AllowedVersionsPerProperty["element"].Contains(requestedVersion)) + writer.WriteStartArray("stakeholderValue"u8); + + foreach(var stakeholderValueItem in iteration.StakeholderValue.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(stakeholderValueItem); } - writer.WriteStartArray("element"u8); + writer.WriteEndArray(); + writer.WriteStartArray("stakeholderValueMap"u8); - if(value is IEnumerable objectListElement) + foreach(var stakeholderValueMapItem in iteration.StakeholderValueMap.OrderBy(x => x, this.GuidComparer)) { - foreach(var elementItem in objectListElement.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(elementItem); - } + writer.WriteStringValue(stakeholderValueMapItem); } - + writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + writer.WritePropertyName("topElement"u8); + + if(iteration.TopElement.HasValue) { - return; + writer.WriteStringValue(iteration.TopElement.Value); + } + else + { + writer.WriteNullValue(); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("valueGroup"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var valueGroupItem in iteration.ValueGroup.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(valueGroupItem); } - + writer.WriteEndArray(); break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Iteration for Version 1.2.0"); + writer.WriteStartArray("actualFiniteStateList"u8); + + foreach(var actualFiniteStateListItem in iteration.ActualFiniteStateList.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(actualFiniteStateListItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(iteration.ClassKind.ToString()); + writer.WritePropertyName("defaultOption"u8); - if(value is IEnumerable objectListExcludedPerson) + if(iteration.DefaultOption.HasValue) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(iteration.DefaultOption.Value); } - - writer.WriteEndArray(); - break; - case "externalidentifiermap": - if(!AllowedVersionsPerProperty["externalIdentifierMap"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("externalIdentifierMap"u8); + writer.WriteStartArray("diagramCanvas"u8); - if(value is IEnumerable objectListExternalIdentifierMap) + foreach(var diagramCanvasItem in iteration.DiagramCanvas.OrderBy(x => x, this.GuidComparer)) { - foreach(var externalIdentifierMapItem in objectListExternalIdentifierMap.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(externalIdentifierMapItem); - } + writer.WriteStringValue(diagramCanvasItem); } - + writer.WriteEndArray(); - break; - case "goal": - if(!AllowedVersionsPerProperty["goal"].Contains(requestedVersion)) + writer.WriteStartArray("domainFileStore"u8); + + foreach(var domainFileStoreItem in iteration.DomainFileStore.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(domainFileStoreItem); } - writer.WriteStartArray("goal"u8); + writer.WriteEndArray(); + writer.WriteStartArray("element"u8); - if(value is IEnumerable objectListGoal) + foreach(var elementItem in iteration.Element.OrderBy(x => x, this.GuidComparer)) { - foreach(var goalItem in objectListGoal.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(goalItem); - } + writer.WriteStringValue(elementItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in iteration.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in iteration.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("externalIdentifierMap"u8); + + foreach(var externalIdentifierMapItem in iteration.ExternalIdentifierMap.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(externalIdentifierMapItem); } - break; - case "iterationsetup": - if(!AllowedVersionsPerProperty["iterationSetup"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("goal"u8); + + foreach(var goalItem in iteration.Goal.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(goalItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(iteration.Iid); writer.WritePropertyName("iterationSetup"u8); - - if(value != null) + writer.WriteStringValue(iteration.IterationSetup); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(iteration.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("option"u8); + + foreach(var optionItem in iteration.Option.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteOrderedItem(optionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("possibleFiniteStateList"u8); + + foreach(var possibleFiniteStateListItem in iteration.PossibleFiniteStateList.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(possibleFiniteStateListItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("publication"u8); + + foreach(var publicationItem in iteration.Publication.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(publicationItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("relationship"u8); + + foreach(var relationshipItem in iteration.Relationship.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(relationshipItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("requirementsSpecification"u8); + + foreach(var requirementsSpecificationItem in iteration.RequirementsSpecification.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(requirementsSpecificationItem); } - break; - case "option": - if(!AllowedVersionsPerProperty["option"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(iteration.RevisionNumber); + writer.WriteStartArray("ruleVerificationList"u8); + + foreach(var ruleVerificationListItem in iteration.RuleVerificationList.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(ruleVerificationListItem); } - writer.WriteStartArray("option"u8); + writer.WriteEndArray(); + writer.WriteStartArray("sharedDiagramStyle"u8); - if(value is IEnumerable objectListOption) + foreach(var sharedDiagramStyleItem in iteration.SharedDiagramStyle.OrderBy(x => x, this.GuidComparer)) { - foreach(var optionItem in objectListOption.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(optionItem); - } + writer.WriteStringValue(sharedDiagramStyleItem); } - + writer.WriteEndArray(); - break; - case "possiblefinitestatelist": - if(!AllowedVersionsPerProperty["possibleFiniteStateList"].Contains(requestedVersion)) + writer.WritePropertyName("sourceIterationIid"u8); + + if(iteration.SourceIterationIid.HasValue) { - return; + writer.WriteStringValue(iteration.SourceIterationIid.Value); + } + else + { + writer.WriteNullValue(); } - writer.WriteStartArray("possibleFiniteStateList"u8); + writer.WriteStartArray("stakeholder"u8); - if(value is IEnumerable objectListPossibleFiniteStateList) + foreach(var stakeholderItem in iteration.Stakeholder.OrderBy(x => x, this.GuidComparer)) { - foreach(var possibleFiniteStateListItem in objectListPossibleFiniteStateList.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(possibleFiniteStateListItem); - } + writer.WriteStringValue(stakeholderItem); } - + writer.WriteEndArray(); - break; - case "publication": - if(!AllowedVersionsPerProperty["publication"].Contains(requestedVersion)) + writer.WriteStartArray("stakeholderValue"u8); + + foreach(var stakeholderValueItem in iteration.StakeholderValue.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(stakeholderValueItem); } - writer.WriteStartArray("publication"u8); + writer.WriteEndArray(); + writer.WriteStartArray("stakeholderValueMap"u8); - if(value is IEnumerable objectListPublication) + foreach(var stakeholderValueMapItem in iteration.StakeholderValueMap.OrderBy(x => x, this.GuidComparer)) { - foreach(var publicationItem in objectListPublication.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(publicationItem); - } + writer.WriteStringValue(stakeholderValueMapItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(iteration.ThingPreference); + writer.WritePropertyName("topElement"u8); + + if(iteration.TopElement.HasValue) + { + writer.WriteStringValue(iteration.TopElement.Value); } - - writer.WriteEndArray(); - break; - case "relationship": - if(!AllowedVersionsPerProperty["relationship"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("relationship"u8); + writer.WriteStartArray("valueGroup"u8); - if(value is IEnumerable objectListRelationship) + foreach(var valueGroupItem in iteration.ValueGroup.OrderBy(x => x, this.GuidComparer)) { - foreach(var relationshipItem in objectListRelationship.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relationshipItem); - } + writer.WriteStringValue(valueGroupItem); } - + writer.WriteEndArray(); break; - case "requirementsspecification": - if(!AllowedVersionsPerProperty["requirementsSpecification"].Contains(requestedVersion)) + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Iteration for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(iteration.Actor.HasValue) { - return; + writer.WriteStringValue(iteration.Actor.Value); + } + else + { + writer.WriteNullValue(); } - writer.WriteStartArray("requirementsSpecification"u8); + writer.WriteStartArray("actualFiniteStateList"u8); - if(value is IEnumerable objectListRequirementsSpecification) + foreach(var actualFiniteStateListItem in iteration.ActualFiniteStateList.OrderBy(x => x, this.GuidComparer)) { - foreach(var requirementsSpecificationItem in objectListRequirementsSpecification.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(requirementsSpecificationItem); - } + writer.WriteStringValue(actualFiniteStateListItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(iteration.ClassKind.ToString()); + writer.WritePropertyName("defaultOption"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(iteration.DefaultOption.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(iteration.DefaultOption.Value); } else { writer.WriteNullValue(); } - break; - case "ruleverificationlist": - if(!AllowedVersionsPerProperty["ruleVerificationList"].Contains(requestedVersion)) + writer.WriteStartArray("diagramCanvas"u8); + + foreach(var diagramCanvasItem in iteration.DiagramCanvas.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(diagramCanvasItem); } - writer.WriteStartArray("ruleVerificationList"u8); + writer.WriteEndArray(); + writer.WriteStartArray("domainFileStore"u8); - if(value is IEnumerable objectListRuleVerificationList) + foreach(var domainFileStoreItem in iteration.DomainFileStore.OrderBy(x => x, this.GuidComparer)) { - foreach(var ruleVerificationListItem in objectListRuleVerificationList.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(ruleVerificationListItem); - } + writer.WriteStringValue(domainFileStoreItem); } - + writer.WriteEndArray(); - break; - case "shareddiagramstyle": - if(!AllowedVersionsPerProperty["sharedDiagramStyle"].Contains(requestedVersion)) + writer.WriteStartArray("element"u8); + + foreach(var elementItem in iteration.Element.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(elementItem); } - writer.WriteStartArray("sharedDiagramStyle"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListSharedDiagramStyle) + foreach(var excludedDomainItem in iteration.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var sharedDiagramStyleItem in objectListSharedDiagramStyle.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sharedDiagramStyleItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "sourceiterationiid": - if(!AllowedVersionsPerProperty["sourceIterationIid"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in iteration.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("sourceIterationIid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("externalIdentifierMap"u8); + + foreach(var externalIdentifierMapItem in iteration.ExternalIdentifierMap.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(externalIdentifierMapItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("goal"u8); + + foreach(var goalItem in iteration.Goal.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(goalItem); } - break; - case "stakeholder": - if(!AllowedVersionsPerProperty["stakeholder"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(iteration.Iid); + writer.WritePropertyName("iterationSetup"u8); + writer.WriteStringValue(iteration.IterationSetup); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(iteration.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("option"u8); + + foreach(var optionItem in iteration.Option.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(optionItem); } - writer.WriteStartArray("stakeholder"u8); + writer.WriteEndArray(); + writer.WriteStartArray("possibleFiniteStateList"u8); - if(value is IEnumerable objectListStakeholder) + foreach(var possibleFiniteStateListItem in iteration.PossibleFiniteStateList.OrderBy(x => x, this.GuidComparer)) { - foreach(var stakeholderItem in objectListStakeholder.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(stakeholderItem); - } + writer.WriteStringValue(possibleFiniteStateListItem); } - + writer.WriteEndArray(); - break; - case "stakeholdervalue": - if(!AllowedVersionsPerProperty["stakeholderValue"].Contains(requestedVersion)) + writer.WriteStartArray("publication"u8); + + foreach(var publicationItem in iteration.Publication.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(publicationItem); } - writer.WriteStartArray("stakeholderValue"u8); + writer.WriteEndArray(); + writer.WriteStartArray("relationship"u8); - if(value is IEnumerable objectListStakeholderValue) + foreach(var relationshipItem in iteration.Relationship.OrderBy(x => x, this.GuidComparer)) { - foreach(var stakeholderValueItem in objectListStakeholderValue.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(stakeholderValueItem); - } + writer.WriteStringValue(relationshipItem); } - + writer.WriteEndArray(); - break; - case "stakeholdervaluemap": - if(!AllowedVersionsPerProperty["stakeholderValueMap"].Contains(requestedVersion)) + writer.WriteStartArray("requirementsSpecification"u8); + + foreach(var requirementsSpecificationItem in iteration.RequirementsSpecification.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(requirementsSpecificationItem); } - writer.WriteStartArray("stakeholderValueMap"u8); + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(iteration.RevisionNumber); + writer.WriteStartArray("ruleVerificationList"u8); - if(value is IEnumerable objectListStakeholderValueMap) + foreach(var ruleVerificationListItem in iteration.RuleVerificationList.OrderBy(x => x, this.GuidComparer)) { - foreach(var stakeholderValueMapItem in objectListStakeholderValueMap.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(stakeholderValueMapItem); - } + writer.WriteStringValue(ruleVerificationListItem); } - + writer.WriteEndArray(); - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("sharedDiagramStyle"u8); + + foreach(var sharedDiagramStyleItem in iteration.SharedDiagramStyle.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(sharedDiagramStyleItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("sourceIterationIid"u8); + + if(iteration.SourceIterationIid.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(iteration.SourceIterationIid.Value); } else { writer.WriteNullValue(); } - break; - case "topelement": - if(!AllowedVersionsPerProperty["topElement"].Contains(requestedVersion)) + writer.WriteStartArray("stakeholder"u8); + + foreach(var stakeholderItem in iteration.Stakeholder.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(stakeholderItem); } - writer.WritePropertyName("topElement"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("stakeholderValue"u8); + + foreach(var stakeholderValueItem in iteration.StakeholderValue.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(stakeholderValueItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("stakeholderValueMap"u8); + + foreach(var stakeholderValueMapItem in iteration.StakeholderValueMap.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(stakeholderValueMapItem); } - break; - case "valuegroup": - if(!AllowedVersionsPerProperty["valueGroup"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(iteration.ThingPreference); + writer.WritePropertyName("topElement"u8); + + if(iteration.TopElement.HasValue) { - return; + writer.WriteStringValue(iteration.TopElement.Value); + } + else + { + writer.WriteNullValue(); } writer.WriteStartArray("valueGroup"u8); - if(value is IEnumerable objectListValueGroup) + foreach(var valueGroupItem in iteration.ValueGroup.OrderBy(x => x, this.GuidComparer)) { - foreach(var valueGroupItem in objectListValueGroup.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueGroupItem); - } + writer.WriteStringValue(valueGroupItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the Iteration"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "actualFiniteStateList", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "defaultOption", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "diagramCanvas", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "domainFileStore", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "element", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "externalIdentifierMap", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "goal", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iterationSetup", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "option", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "possibleFiniteStateList", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "publication", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "relationship", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "requirementsSpecification", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "ruleVerificationList", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "sharedDiagramStyle", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "sourceIterationIid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "stakeholder", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "stakeholderValue", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "stakeholderValueMap", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "topElement", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "valueGroup", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/IterationSetupSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/IterationSetupSerializer.cs index ade20684..5f6ab136 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/IterationSetupSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/IterationSetupSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,64 +50,60 @@ namespace CDP4JsonSerializer public class IterationSetupSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not IterationSetup iterationSetup) - { - throw new ArgumentException("The thing shall be a IterationSetup", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.0.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of IterationSetup since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing IterationSetup for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(iterationSetup.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(iterationSetup.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("description"u8); - writer.WriteStringValue(iterationSetup.Description); - writer.WritePropertyName("frozenOn"u8); + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } - if(iterationSetup.FrozenOn.HasValue) + writer.WritePropertyName("actor"u8); + + if(value != null) { - writer.WriteStringValue(iterationSetup.FrozenOn.Value.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(iterationSetup.Iid); - writer.WritePropertyName("isDeleted"u8); - writer.WriteBooleanValue(iterationSetup.IsDeleted); - writer.WritePropertyName("iterationIid"u8); - writer.WriteStringValue(iterationSetup.IterationIid); - writer.WritePropertyName("iterationNumber"u8); - writer.WriteNumberValue(iterationSetup.IterationNumber); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(iterationSetup.RevisionNumber); - writer.WritePropertyName("sourceIterationSetup"u8); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(iterationSetup.SourceIterationSetup.HasValue) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(iterationSetup.SourceIterationSetup.Value); + return; + } + + writer.WritePropertyName("classKind"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); } else { @@ -116,60 +111,51 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing IterationSetup for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(iterationSetup.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(iterationSetup.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("description"u8); - writer.WriteStringValue(iterationSetup.Description); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in iterationSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + case "createdon": + var allowedVersionsForCreatedOn = new List { - writer.WriteStringValue(excludedDomainItem); - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in iterationSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("createdOn"u8); - writer.WritePropertyName("frozenOn"u8); - - if(iterationSetup.FrozenOn.HasValue) + if(value != null) { - writer.WriteStringValue(iterationSetup.FrozenOn.Value.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(iterationSetup.Iid); - writer.WritePropertyName("isDeleted"u8); - writer.WriteBooleanValue(iterationSetup.IsDeleted); - writer.WritePropertyName("iterationIid"u8); - writer.WriteStringValue(iterationSetup.IterationIid); - writer.WritePropertyName("iterationNumber"u8); - writer.WriteNumberValue(iterationSetup.IterationNumber); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(iterationSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(iterationSetup.RevisionNumber); - writer.WritePropertyName("sourceIterationSetup"u8); + break; + case "description": + var allowedVersionsForDescription = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(iterationSetup.SourceIterationSetup.HasValue) + if(!allowedVersionsForDescription.Contains(requestedVersion)) { - writer.WriteStringValue(iterationSetup.SourceIterationSetup.Value); + return; + } + + writer.WritePropertyName("description"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); } else { @@ -177,175 +163,230 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing IterationSetup for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(iterationSetup.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(iterationSetup.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("description"u8); - writer.WriteStringValue(iterationSetup.Description); - writer.WriteStartArray("excludedDomain"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in iterationSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in iterationSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } - writer.WritePropertyName("frozenOn"u8); + writer.WriteEndArray(); + break; + case "frozenon": + var allowedVersionsForFrozenOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(iterationSetup.FrozenOn.HasValue) + if(!allowedVersionsForFrozenOn.Contains(requestedVersion)) { - writer.WriteStringValue(iterationSetup.FrozenOn.Value.ToString(SerializerHelper.DateTimeFormat)); + return; + } + + writer.WritePropertyName("frozenOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(iterationSetup.Iid); - writer.WritePropertyName("isDeleted"u8); - writer.WriteBooleanValue(iterationSetup.IsDeleted); - writer.WritePropertyName("iterationIid"u8); - writer.WriteStringValue(iterationSetup.IterationIid); - writer.WritePropertyName("iterationNumber"u8); - writer.WriteNumberValue(iterationSetup.IterationNumber); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(iterationSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(iterationSetup.RevisionNumber); - writer.WritePropertyName("sourceIterationSetup"u8); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(iterationSetup.SourceIterationSetup.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(iterationSetup.SourceIterationSetup.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(iterationSetup.ThingPreference); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing IterationSetup for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "isdeleted": + var allowedVersionsForIsDeleted = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(iterationSetup.Actor.HasValue) + if(!allowedVersionsForIsDeleted.Contains(requestedVersion)) { - writer.WriteStringValue(iterationSetup.Actor.Value); + return; + } + + writer.WritePropertyName("isDeleted"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(iterationSetup.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(iterationSetup.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("description"u8); - writer.WriteStringValue(iterationSetup.Description); - writer.WriteStartArray("excludedDomain"u8); + break; + case "iterationiid": + var allowedVersionsForIterationIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in iterationSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIterationIid.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iterationIid"u8); - writer.WriteStartArray("excludedPerson"u8); + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedPersonItem in iterationSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "iterationnumber": + var allowedVersionsForIterationNumber = new List { - writer.WriteStringValue(excludedPersonItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIterationNumber.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iterationNumber"u8); - writer.WritePropertyName("frozenOn"u8); - - if(iterationSetup.FrozenOn.HasValue) + if(value != null) { - writer.WriteStringValue(iterationSetup.FrozenOn.Value.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteNumberValue((int)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(iterationSetup.Iid); - writer.WritePropertyName("isDeleted"u8); - writer.WriteBooleanValue(iterationSetup.IsDeleted); - writer.WritePropertyName("iterationIid"u8); - writer.WriteStringValue(iterationSetup.IterationIid); - writer.WritePropertyName("iterationNumber"u8); - writer.WriteNumberValue(iterationSetup.IterationNumber); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(iterationSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(iterationSetup.RevisionNumber); - writer.WritePropertyName("sourceIterationSetup"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(iterationSetup.SourceIterationSetup.HasValue) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(iterationSetup.SourceIterationSetup.Value); + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(iterationSetup.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -353,17 +394,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "sourceiterationsetup": + var allowedVersionsForSourceIterationSetup = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSourceIterationSetup.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("sourceIterationSetup"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((Guid)value); } else { @@ -371,35 +420,94 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the IterationSetup"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not IterationSetup iterationSetup) + { + throw new ArgumentException("The thing shall be a IterationSetup", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of IterationSetup since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing IterationSetup for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(iterationSetup.ClassKind.ToString()); writer.WritePropertyName("createdOn"u8); - - if(value != null) + writer.WriteStringValue(iterationSetup.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("description"u8); + writer.WriteStringValue(iterationSetup.Description); + writer.WritePropertyName("frozenOn"u8); + + if(iterationSetup.FrozenOn.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(iterationSetup.FrozenOn.Value.ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - break; - case "description": - if(!AllowedVersionsPerProperty["description"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(iterationSetup.Iid); + writer.WritePropertyName("isDeleted"u8); + writer.WriteBooleanValue(iterationSetup.IsDeleted); + writer.WritePropertyName("iterationIid"u8); + writer.WriteStringValue(iterationSetup.IterationIid); + writer.WritePropertyName("iterationNumber"u8); + writer.WriteNumberValue(iterationSetup.IterationNumber); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(iterationSetup.RevisionNumber); + writer.WritePropertyName("sourceIterationSetup"u8); - writer.WritePropertyName("description"u8); - - if(value != null) + if(iterationSetup.SourceIterationSetup.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(iterationSetup.SourceIterationSetup.Value); } else { @@ -407,71 +515,58 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing IterationSetup for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(iterationSetup.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(iterationSetup.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("description"u8); + writer.WriteStringValue(iterationSetup.Description); writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + foreach(var excludedDomainItem in iterationSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "frozenon": - if(!AllowedVersionsPerProperty["frozenOn"].Contains(requestedVersion)) + foreach(var excludedPersonItem in iterationSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WritePropertyName("frozenOn"u8); - - if(value != null) + + if(iterationSetup.FrozenOn.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(iterationSetup.FrozenOn.Value.ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteStringValue(iterationSetup.Iid); + writer.WritePropertyName("isDeleted"u8); + writer.WriteBooleanValue(iterationSetup.IsDeleted); + writer.WritePropertyName("iterationIid"u8); + writer.WriteStringValue(iterationSetup.IterationIid); + writer.WritePropertyName("iterationNumber"u8); + writer.WriteNumberValue(iterationSetup.IterationNumber); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(iterationSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(iterationSetup.RevisionNumber); + writer.WritePropertyName("sourceIterationSetup"u8); + + if(iterationSetup.SourceIterationSetup.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(iterationSetup.SourceIterationSetup.Value); } else { @@ -479,158 +574,145 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeleted": - if(!AllowedVersionsPerProperty["isDeleted"].Contains(requestedVersion)) - { - return; - } + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing IterationSetup for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(iterationSetup.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(iterationSetup.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("description"u8); + writer.WriteStringValue(iterationSetup.Description); + writer.WriteStartArray("excludedDomain"u8); - writer.WritePropertyName("isDeleted"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else + foreach(var excludedDomainItem in iterationSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "iterationiid": - if(!AllowedVersionsPerProperty["iterationIid"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in iterationSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("iterationIid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("frozenOn"u8); + + if(iterationSetup.FrozenOn.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(iterationSetup.FrozenOn.Value.ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - break; - case "iterationnumber": - if(!AllowedVersionsPerProperty["iterationNumber"].Contains(requestedVersion)) - { - return; - } - + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(iterationSetup.Iid); + writer.WritePropertyName("isDeleted"u8); + writer.WriteBooleanValue(iterationSetup.IsDeleted); + writer.WritePropertyName("iterationIid"u8); + writer.WriteStringValue(iterationSetup.IterationIid); writer.WritePropertyName("iterationNumber"u8); - - if(value != null) + writer.WriteNumberValue(iterationSetup.IterationNumber); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(iterationSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(iterationSetup.RevisionNumber); + writer.WritePropertyName("sourceIterationSetup"u8); + + if(iterationSetup.SourceIterationSetup.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(iterationSetup.SourceIterationSetup.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(iterationSetup.ThingPreference); break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing IterationSetup for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + if(iterationSetup.Actor.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(iterationSetup.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(iterationSetup.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(iterationSetup.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("description"u8); + writer.WriteStringValue(iterationSetup.Description); + writer.WriteStartArray("excludedDomain"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else + foreach(var excludedDomainItem in iterationSetup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "sourceiterationsetup": - if(!AllowedVersionsPerProperty["sourceIterationSetup"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in iterationSetup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("sourceIterationSetup"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("frozenOn"u8); + + if(iterationSetup.FrozenOn.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(iterationSetup.FrozenOn.Value.ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(iterationSetup.Iid); + writer.WritePropertyName("isDeleted"u8); + writer.WriteBooleanValue(iterationSetup.IsDeleted); + writer.WritePropertyName("iterationIid"u8); + writer.WriteStringValue(iterationSetup.IterationIid); + writer.WritePropertyName("iterationNumber"u8); + writer.WriteNumberValue(iterationSetup.IterationNumber); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(iterationSetup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(iterationSetup.RevisionNumber); + writer.WritePropertyName("sourceIterationSetup"u8); - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + if(iterationSetup.SourceIterationSetup.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(iterationSetup.SourceIterationSetup.Value); } else { writer.WriteNullValue(); } + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(iterationSetup.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the IterationSetup"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "description", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "frozenOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeleted", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iterationIid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iterationNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "sourceIterationSetup", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/LinearConversionUnitSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/LinearConversionUnitSerializer.cs index 6a462edc..75ef50fd 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/LinearConversionUnitSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/LinearConversionUnitSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,317 +50,236 @@ namespace CDP4JsonSerializer public class LinearConversionUnitSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not LinearConversionUnit linearConversionUnit) - { - throw new ArgumentException("The thing shall be a LinearConversionUnit", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of LinearConversionUnit since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing LinearConversionUnit for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in linearConversionUnit.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(linearConversionUnit.ClassKind.ToString()); - writer.WritePropertyName("conversionFactor"u8); - writer.WriteStringValue(linearConversionUnit.ConversionFactor); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in linearConversionUnit.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in linearConversionUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(linearConversionUnit.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(linearConversionUnit.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(linearConversionUnit.Name); - writer.WritePropertyName("referenceUnit"u8); - writer.WriteStringValue(linearConversionUnit.ReferenceUnit); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(linearConversionUnit.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(linearConversionUnit.ShortName); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing LinearConversionUnit for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in linearConversionUnit.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(linearConversionUnit.ClassKind.ToString()); - writer.WritePropertyName("conversionFactor"u8); - writer.WriteStringValue(linearConversionUnit.ConversionFactor); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("alias"u8); - foreach(var definitionItem in linearConversionUnit.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(definitionItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in linearConversionUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in linearConversionUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in linearConversionUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(linearConversionUnit.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(linearConversionUnit.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(linearConversionUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(linearConversionUnit.Name); - writer.WritePropertyName("referenceUnit"u8); - writer.WriteStringValue(linearConversionUnit.ReferenceUnit); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(linearConversionUnit.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(linearConversionUnit.ShortName); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing LinearConversionUnit for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "conversionfactor": + var allowedVersionsForConversionFactor = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in linearConversionUnit.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForConversionFactor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(linearConversionUnit.ClassKind.ToString()); writer.WritePropertyName("conversionFactor"u8); - writer.WriteStringValue(linearConversionUnit.ConversionFactor); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in linearConversionUnit.Definition.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in linearConversionUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in linearConversionUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in linearConversionUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(linearConversionUnit.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(linearConversionUnit.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(linearConversionUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(linearConversionUnit.Name); - writer.WritePropertyName("referenceUnit"u8); - writer.WriteStringValue(linearConversionUnit.ReferenceUnit); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(linearConversionUnit.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(linearConversionUnit.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(linearConversionUnit.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing LinearConversionUnit for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(linearConversionUnit.Actor.HasValue) + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteStringValue(linearConversionUnit.Actor.Value); - } - else + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteNullValue(); + return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var aliasItem in linearConversionUnit.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(aliasItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(linearConversionUnit.ClassKind.ToString()); - writer.WritePropertyName("conversionFactor"u8); - writer.WriteStringValue(linearConversionUnit.ConversionFactor); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in linearConversionUnit.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in linearConversionUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in linearConversionUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in linearConversionUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(linearConversionUnit.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(linearConversionUnit.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(linearConversionUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(linearConversionUnit.Name); - writer.WritePropertyName("referenceUnit"u8); - writer.WriteStringValue(linearConversionUnit.ReferenceUnit); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(linearConversionUnit.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(linearConversionUnit.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(linearConversionUnit.ThingPreference); + writer.WriteEndArray(); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("iid"u8); if(value != null) { @@ -373,35 +291,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("isDeprecated"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteBooleanValue((bool)value); } else { @@ -409,17 +317,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "conversionfactor": - if(!AllowedVersionsPerProperty["conversionFactor"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("conversionFactor"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -427,85 +342,47 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List { - return; - } - - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } + writer.WritePropertyName("name"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "referenceunit": + var allowedVersionsForReferenceUnit = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForReferenceUnit.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("referenceUnit"u8); if(value != null) { @@ -517,17 +394,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isDeprecated"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteNumberValue((int)value); } else { @@ -535,17 +420,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((string)value); } else { @@ -553,13 +446,19 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("name"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { @@ -571,105 +470,283 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "referenceunit": - if(!AllowedVersionsPerProperty["referenceUnit"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the LinearConversionUnit"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not LinearConversionUnit linearConversionUnit) + { + throw new ArgumentException("The thing shall be a LinearConversionUnit", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of LinearConversionUnit since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing LinearConversionUnit for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in linearConversionUnit.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("referenceUnit"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(linearConversionUnit.ClassKind.ToString()); + writer.WritePropertyName("conversionFactor"u8); + writer.WriteStringValue(linearConversionUnit.ConversionFactor); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in linearConversionUnit.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in linearConversionUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(linearConversionUnit.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(linearConversionUnit.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(linearConversionUnit.Name); + writer.WritePropertyName("referenceUnit"u8); + writer.WriteStringValue(linearConversionUnit.ReferenceUnit); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(linearConversionUnit.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(linearConversionUnit.ShortName); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing LinearConversionUnit for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in linearConversionUnit.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(linearConversionUnit.ClassKind.ToString()); + writer.WritePropertyName("conversionFactor"u8); + writer.WriteStringValue(linearConversionUnit.ConversionFactor); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in linearConversionUnit.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in linearConversionUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in linearConversionUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in linearConversionUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(linearConversionUnit.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(linearConversionUnit.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(linearConversionUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(linearConversionUnit.Name); + writer.WritePropertyName("referenceUnit"u8); + writer.WriteStringValue(linearConversionUnit.ReferenceUnit); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(linearConversionUnit.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(linearConversionUnit.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing LinearConversionUnit for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in linearConversionUnit.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(linearConversionUnit.ClassKind.ToString()); + writer.WritePropertyName("conversionFactor"u8); + writer.WriteStringValue(linearConversionUnit.ConversionFactor); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in linearConversionUnit.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in linearConversionUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in linearConversionUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in linearConversionUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(linearConversionUnit.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(linearConversionUnit.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(linearConversionUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(linearConversionUnit.Name); + writer.WritePropertyName("referenceUnit"u8); + writer.WriteStringValue(linearConversionUnit.ReferenceUnit); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(linearConversionUnit.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(linearConversionUnit.ShortName); writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteStringValue(linearConversionUnit.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing LinearConversionUnit for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(linearConversionUnit.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(linearConversionUnit.Actor.Value); } else { writer.WriteNullValue(); } + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in linearConversionUnit.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(linearConversionUnit.ClassKind.ToString()); + writer.WritePropertyName("conversionFactor"u8); + writer.WriteStringValue(linearConversionUnit.ConversionFactor); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in linearConversionUnit.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in linearConversionUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in linearConversionUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in linearConversionUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(linearConversionUnit.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(linearConversionUnit.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(linearConversionUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(linearConversionUnit.Name); + writer.WritePropertyName("referenceUnit"u8); + writer.WriteStringValue(linearConversionUnit.ReferenceUnit); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(linearConversionUnit.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(linearConversionUnit.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(linearConversionUnit.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the LinearConversionUnit"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "conversionFactor", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "referenceUnit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/LogEntryChangelogItemSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/LogEntryChangelogItemSerializer.cs index b6919f1e..bb2eb50c 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/LogEntryChangelogItemSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/LogEntryChangelogItemSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,141 +49,6 @@ namespace CDP4JsonSerializer /// public class LogEntryChangelogItemSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not LogEntryChangelogItem logEntryChangelogItem) - { - throw new ArgumentException("The thing shall be a LogEntryChangelogItem", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.2.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of LogEntryChangelogItem since Version is below 1.2.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing LogEntryChangelogItem for Version 1.2.0"); - writer.WritePropertyName("affectedItemIid"u8); - writer.WriteStringValue(logEntryChangelogItem.AffectedItemIid); - writer.WriteStartArray("affectedReferenceIid"u8); - - foreach(var affectedReferenceIidItem in logEntryChangelogItem.AffectedReferenceIid) - { - writer.WriteStringValue(affectedReferenceIidItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("changeDescription"u8); - writer.WriteStringValue(logEntryChangelogItem.ChangeDescription); - writer.WritePropertyName("changelogKind"u8); - writer.WriteStringValue(logEntryChangelogItem.ChangelogKind.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(logEntryChangelogItem.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in logEntryChangelogItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in logEntryChangelogItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(logEntryChangelogItem.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(logEntryChangelogItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(logEntryChangelogItem.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(logEntryChangelogItem.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing LogEntryChangelogItem for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(logEntryChangelogItem.Actor.HasValue) - { - writer.WriteStringValue(logEntryChangelogItem.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("affectedItemIid"u8); - writer.WriteStringValue(logEntryChangelogItem.AffectedItemIid); - writer.WriteStartArray("affectedReferenceIid"u8); - - foreach(var affectedReferenceIidItem in logEntryChangelogItem.AffectedReferenceIid) - { - writer.WriteStringValue(affectedReferenceIidItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("changeDescription"u8); - writer.WriteStringValue(logEntryChangelogItem.ChangeDescription); - writer.WritePropertyName("changelogKind"u8); - writer.WriteStringValue(logEntryChangelogItem.ChangelogKind.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(logEntryChangelogItem.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in logEntryChangelogItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in logEntryChangelogItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(logEntryChangelogItem.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(logEntryChangelogItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(logEntryChangelogItem.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(logEntryChangelogItem.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -192,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -200,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -218,7 +86,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "affecteditemiid": - if(!AllowedVersionsPerProperty["affectedItemIid"].Contains(requestedVersion)) + var allowedVersionsForAffectedItemIid = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAffectedItemIid.Contains(requestedVersion)) { return; } @@ -236,7 +110,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "affectedreferenceiid": - if(!AllowedVersionsPerProperty["affectedReferenceIid"].Contains(requestedVersion)) + var allowedVersionsForAffectedReferenceIid = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAffectedReferenceIid.Contains(requestedVersion)) { return; } @@ -254,7 +134,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "changedescription": - if(!AllowedVersionsPerProperty["changeDescription"].Contains(requestedVersion)) + var allowedVersionsForChangeDescription = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForChangeDescription.Contains(requestedVersion)) { return; } @@ -272,7 +158,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "changelogkind": - if(!AllowedVersionsPerProperty["changelogKind"].Contains(requestedVersion)) + var allowedVersionsForChangelogKind = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForChangelogKind.Contains(requestedVersion)) { return; } @@ -290,7 +182,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -308,7 +206,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -326,7 +231,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -344,7 +256,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -362,7 +280,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -380,7 +305,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -398,7 +329,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -421,23 +358,133 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "affectedItemIid", new []{ "1.2.0", "1.3.0" }}, - { "affectedReferenceIid", new []{ "1.2.0", "1.3.0" }}, - { "changeDescription", new []{ "1.2.0", "1.3.0" }}, - { "changelogKind", new []{ "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not LogEntryChangelogItem logEntryChangelogItem) + { + throw new ArgumentException("The thing shall be a LogEntryChangelogItem", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.2.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of LogEntryChangelogItem since Version is below 1.2.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing LogEntryChangelogItem for Version 1.2.0"); + writer.WritePropertyName("affectedItemIid"u8); + writer.WriteStringValue(logEntryChangelogItem.AffectedItemIid); + writer.WriteStartArray("affectedReferenceIid"u8); + + foreach(var affectedReferenceIidItem in logEntryChangelogItem.AffectedReferenceIid) + { + writer.WriteStringValue(affectedReferenceIidItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("changeDescription"u8); + writer.WriteStringValue(logEntryChangelogItem.ChangeDescription); + writer.WritePropertyName("changelogKind"u8); + writer.WriteStringValue(logEntryChangelogItem.ChangelogKind.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(logEntryChangelogItem.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in logEntryChangelogItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in logEntryChangelogItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(logEntryChangelogItem.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(logEntryChangelogItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(logEntryChangelogItem.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(logEntryChangelogItem.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing LogEntryChangelogItem for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(logEntryChangelogItem.Actor.HasValue) + { + writer.WriteStringValue(logEntryChangelogItem.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("affectedItemIid"u8); + writer.WriteStringValue(logEntryChangelogItem.AffectedItemIid); + writer.WriteStartArray("affectedReferenceIid"u8); + + foreach(var affectedReferenceIidItem in logEntryChangelogItem.AffectedReferenceIid) + { + writer.WriteStringValue(affectedReferenceIidItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("changeDescription"u8); + writer.WriteStringValue(logEntryChangelogItem.ChangeDescription); + writer.WritePropertyName("changelogKind"u8); + writer.WriteStringValue(logEntryChangelogItem.ChangelogKind.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(logEntryChangelogItem.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in logEntryChangelogItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in logEntryChangelogItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(logEntryChangelogItem.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(logEntryChangelogItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(logEntryChangelogItem.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(logEntryChangelogItem.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/LogarithmicScaleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/LogarithmicScaleSerializer.cs index 04e2d998..efd6a6ff 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/LogarithmicScaleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/LogarithmicScaleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,509 +50,370 @@ namespace CDP4JsonSerializer public class LogarithmicScaleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not LogarithmicScale logarithmicScale) - { - throw new ArgumentException("The thing shall be a LogarithmicScale", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of LogarithmicScale since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing LogarithmicScale for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in logarithmicScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(logarithmicScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in logarithmicScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(logarithmicScale.Exponent); - writer.WritePropertyName("factor"u8); - writer.WriteStringValue(logarithmicScale.Factor); - writer.WriteStartArray("hyperLink"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in logarithmicScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(logarithmicScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(logarithmicScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(logarithmicScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(logarithmicScale.IsMinimumInclusive); - writer.WritePropertyName("logarithmBase"u8); - writer.WriteStringValue(logarithmicScale.LogarithmBase.ToString()); - writer.WriteStartArray("mappingToReferenceScale"u8); + writer.WriteStartArray("alias"u8); - foreach(var mappingToReferenceScaleItem in logarithmicScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(mappingToReferenceScaleItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(logarithmicScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(logarithmicScale.MinimumPermissibleValue); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(logarithmicScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(logarithmicScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(logarithmicScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(logarithmicScale.PositiveValueConnotation); - writer.WritePropertyName("referenceQuantityKind"u8); - writer.WriteStringValue(logarithmicScale.ReferenceQuantityKind); - writer.WriteStartArray("referenceQuantityValue"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var referenceQuantityValueItem in logarithmicScale.ReferenceQuantityValue.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(referenceQuantityValueItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(logarithmicScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(logarithmicScale.ShortName); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(logarithmicScale.Unit); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in logarithmicScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(valueDefinitionItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing LogarithmicScale for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in logarithmicScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(logarithmicScale.ClassKind.ToString()); writer.WriteStartArray("definition"u8); - foreach(var definitionItem in logarithmicScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(definitionItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in logarithmicScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var excludedPersonItem in logarithmicScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(logarithmicScale.Exponent); - writer.WritePropertyName("factor"u8); - writer.WriteStringValue(logarithmicScale.Factor); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in logarithmicScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(logarithmicScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(logarithmicScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(logarithmicScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(logarithmicScale.IsMinimumInclusive); - writer.WritePropertyName("logarithmBase"u8); - writer.WriteStringValue(logarithmicScale.LogarithmBase.ToString()); - writer.WriteStartArray("mappingToReferenceScale"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var mappingToReferenceScaleItem in logarithmicScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(mappingToReferenceScaleItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(logarithmicScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(logarithmicScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(logarithmicScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(logarithmicScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(logarithmicScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(logarithmicScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(logarithmicScale.PositiveValueConnotation); - writer.WritePropertyName("referenceQuantityKind"u8); - writer.WriteStringValue(logarithmicScale.ReferenceQuantityKind); - writer.WriteStartArray("referenceQuantityValue"u8); + writer.WriteEndArray(); + break; + case "exponent": + var allowedVersionsForExponent = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var referenceQuantityValueItem in logarithmicScale.ReferenceQuantityValue.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExponent.Contains(requestedVersion)) { - writer.WriteStringValue(referenceQuantityValueItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("exponent"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(logarithmicScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(logarithmicScale.ShortName); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(logarithmicScale.Unit); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in logarithmicScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(valueDefinitionItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing LogarithmicScale for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "factor": + var allowedVersionsForFactor = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in logarithmicScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForFactor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("factor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(logarithmicScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in logarithmicScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in logarithmicScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in logarithmicScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(logarithmicScale.Exponent); - writer.WritePropertyName("factor"u8); - writer.WriteStringValue(logarithmicScale.Factor); writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in logarithmicScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(logarithmicScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(logarithmicScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(logarithmicScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(logarithmicScale.IsMinimumInclusive); - writer.WritePropertyName("logarithmBase"u8); - writer.WriteStringValue(logarithmicScale.LogarithmBase.ToString()); - writer.WriteStartArray("mappingToReferenceScale"u8); - - foreach(var mappingToReferenceScaleItem in logarithmicScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(mappingToReferenceScaleItem); - } - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(logarithmicScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(logarithmicScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(logarithmicScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(logarithmicScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(logarithmicScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(logarithmicScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(logarithmicScale.PositiveValueConnotation); - writer.WritePropertyName("referenceQuantityKind"u8); - writer.WriteStringValue(logarithmicScale.ReferenceQuantityKind); - writer.WriteStartArray("referenceQuantityValue"u8); - - foreach(var referenceQuantityValueItem in logarithmicScale.ReferenceQuantityValue.OrderBy(x => x, this.GuidComparer)) + break; + case "iid": + var allowedVersionsForIid = new List { - writer.WriteStringValue(referenceQuantityValueItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(logarithmicScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(logarithmicScale.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(logarithmicScale.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(logarithmicScale.Unit); - writer.WriteStartArray("valueDefinition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var valueDefinitionItem in logarithmicScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(valueDefinitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing LogarithmicScale for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(logarithmicScale.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(logarithmicScale.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in logarithmicScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(logarithmicScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in logarithmicScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in logarithmicScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "ismaximuminclusive": + var allowedVersionsForIsMaximumInclusive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in logarithmicScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsMaximumInclusive.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isMaximumInclusive"u8); - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(logarithmicScale.Exponent); - writer.WritePropertyName("factor"u8); - writer.WriteStringValue(logarithmicScale.Factor); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in logarithmicScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(logarithmicScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(logarithmicScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(logarithmicScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(logarithmicScale.IsMinimumInclusive); - writer.WritePropertyName("logarithmBase"u8); - writer.WriteStringValue(logarithmicScale.LogarithmBase.ToString()); - writer.WriteStartArray("mappingToReferenceScale"u8); - - foreach(var mappingToReferenceScaleItem in logarithmicScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(mappingToReferenceScaleItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(logarithmicScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(logarithmicScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(logarithmicScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(logarithmicScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(logarithmicScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(logarithmicScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(logarithmicScale.PositiveValueConnotation); - writer.WritePropertyName("referenceQuantityKind"u8); - writer.WriteStringValue(logarithmicScale.ReferenceQuantityKind); - writer.WriteStartArray("referenceQuantityValue"u8); + break; + case "isminimuminclusive": + var allowedVersionsForIsMinimumInclusive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var referenceQuantityValueItem in logarithmicScale.ReferenceQuantityValue.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsMinimumInclusive.Contains(requestedVersion)) { - writer.WriteStringValue(referenceQuantityValueItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isMinimumInclusive"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(logarithmicScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(logarithmicScale.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(logarithmicScale.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(logarithmicScale.Unit); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in logarithmicScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(valueDefinitionItem); + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "logarithmbase": + var allowedVersionsForLogarithmBase = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForLogarithmBase.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("logarithmBase"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((LogarithmBaseKind)value).ToString()); } else { @@ -561,260 +421,42 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "mappingtoreferencescale": + var allowedVersionsForMappingToReferenceScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMappingToReferenceScale.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("mappingToReferenceScale"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListMappingToReferenceScale) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var mappingToReferenceScaleItem in objectListMappingToReferenceScale.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteStringValue(mappingToReferenceScaleItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "maximumpermissiblevalue": + var allowedVersionsForMaximumPermissibleValue = new List { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "exponent": - if(!AllowedVersionsPerProperty["exponent"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("exponent"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "factor": - if(!AllowedVersionsPerProperty["factor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("factor"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "ismaximuminclusive": - if(!AllowedVersionsPerProperty["isMaximumInclusive"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("isMaximumInclusive"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "isminimuminclusive": - if(!AllowedVersionsPerProperty["isMinimumInclusive"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("isMinimumInclusive"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "logarithmbase": - if(!AllowedVersionsPerProperty["logarithmBase"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("logarithmBase"u8); - - if(value != null) - { - writer.WriteStringValue(((LogarithmBaseKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "mappingtoreferencescale": - if(!AllowedVersionsPerProperty["mappingToReferenceScale"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("mappingToReferenceScale"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListMappingToReferenceScale) - { - foreach(var mappingToReferenceScaleItem in objectListMappingToReferenceScale.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(mappingToReferenceScaleItem); - } - } - - writer.WriteEndArray(); - break; - case "maximumpermissiblevalue": - if(!AllowedVersionsPerProperty["maximumPermissibleValue"].Contains(requestedVersion)) + if(!allowedVersionsForMaximumPermissibleValue.Contains(requestedVersion)) { return; } @@ -832,7 +474,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "minimumpermissiblevalue": - if(!AllowedVersionsPerProperty["minimumPermissibleValue"].Contains(requestedVersion)) + var allowedVersionsForMinimumPermissibleValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMinimumPermissibleValue.Contains(requestedVersion)) { return; } @@ -850,7 +500,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -868,7 +525,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -886,7 +551,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "negativevalueconnotation": - if(!AllowedVersionsPerProperty["negativeValueConnotation"].Contains(requestedVersion)) + var allowedVersionsForNegativeValueConnotation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNegativeValueConnotation.Contains(requestedVersion)) { return; } @@ -904,7 +577,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "numberset": - if(!AllowedVersionsPerProperty["numberSet"].Contains(requestedVersion)) + var allowedVersionsForNumberSet = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNumberSet.Contains(requestedVersion)) { return; } @@ -922,7 +603,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "positivevalueconnotation": - if(!AllowedVersionsPerProperty["positiveValueConnotation"].Contains(requestedVersion)) + var allowedVersionsForPositiveValueConnotation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPositiveValueConnotation.Contains(requestedVersion)) { return; } @@ -940,7 +629,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "referencequantitykind": - if(!AllowedVersionsPerProperty["referenceQuantityKind"].Contains(requestedVersion)) + var allowedVersionsForReferenceQuantityKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReferenceQuantityKind.Contains(requestedVersion)) { return; } @@ -958,7 +655,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "referencequantityvalue": - if(!AllowedVersionsPerProperty["referenceQuantityValue"].Contains(requestedVersion)) + var allowedVersionsForReferenceQuantityValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReferenceQuantityValue.Contains(requestedVersion)) { return; } @@ -976,7 +681,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -994,7 +707,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -1012,7 +733,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -1030,7 +757,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "unit": - if(!AllowedVersionsPerProperty["unit"].Contains(requestedVersion)) + var allowedVersionsForUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUnit.Contains(requestedVersion)) { return; } @@ -1048,7 +783,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "valuedefinition": - if(!AllowedVersionsPerProperty["valueDefinition"].Contains(requestedVersion)) + var allowedVersionsForValueDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueDefinition.Contains(requestedVersion)) { return; } @@ -1071,40 +814,453 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "exponent", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "factor", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isMaximumInclusive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isMinimumInclusive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "logarithmBase", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "mappingToReferenceScale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "maximumPermissibleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "minimumPermissibleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "negativeValueConnotation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "numberSet", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "positiveValueConnotation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "referenceQuantityKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "referenceQuantityValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "unit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "valueDefinition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not LogarithmicScale logarithmicScale) + { + throw new ArgumentException("The thing shall be a LogarithmicScale", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of LogarithmicScale since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing LogarithmicScale for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in logarithmicScale.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(logarithmicScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in logarithmicScale.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(logarithmicScale.Exponent); + writer.WritePropertyName("factor"u8); + writer.WriteStringValue(logarithmicScale.Factor); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in logarithmicScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(logarithmicScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(logarithmicScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(logarithmicScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(logarithmicScale.IsMinimumInclusive); + writer.WritePropertyName("logarithmBase"u8); + writer.WriteStringValue(logarithmicScale.LogarithmBase.ToString()); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in logarithmicScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(mappingToReferenceScaleItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(logarithmicScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(logarithmicScale.MinimumPermissibleValue); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(logarithmicScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(logarithmicScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(logarithmicScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(logarithmicScale.PositiveValueConnotation); + writer.WritePropertyName("referenceQuantityKind"u8); + writer.WriteStringValue(logarithmicScale.ReferenceQuantityKind); + writer.WriteStartArray("referenceQuantityValue"u8); + + foreach(var referenceQuantityValueItem in logarithmicScale.ReferenceQuantityValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referenceQuantityValueItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(logarithmicScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(logarithmicScale.ShortName); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(logarithmicScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in logarithmicScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueDefinitionItem); + } + + writer.WriteEndArray(); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing LogarithmicScale for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in logarithmicScale.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(logarithmicScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in logarithmicScale.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in logarithmicScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in logarithmicScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(logarithmicScale.Exponent); + writer.WritePropertyName("factor"u8); + writer.WriteStringValue(logarithmicScale.Factor); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in logarithmicScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(logarithmicScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(logarithmicScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(logarithmicScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(logarithmicScale.IsMinimumInclusive); + writer.WritePropertyName("logarithmBase"u8); + writer.WriteStringValue(logarithmicScale.LogarithmBase.ToString()); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in logarithmicScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(mappingToReferenceScaleItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(logarithmicScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(logarithmicScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(logarithmicScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(logarithmicScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(logarithmicScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(logarithmicScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(logarithmicScale.PositiveValueConnotation); + writer.WritePropertyName("referenceQuantityKind"u8); + writer.WriteStringValue(logarithmicScale.ReferenceQuantityKind); + writer.WriteStartArray("referenceQuantityValue"u8); + + foreach(var referenceQuantityValueItem in logarithmicScale.ReferenceQuantityValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referenceQuantityValueItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(logarithmicScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(logarithmicScale.ShortName); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(logarithmicScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in logarithmicScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueDefinitionItem); + } + + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing LogarithmicScale for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in logarithmicScale.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(logarithmicScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in logarithmicScale.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in logarithmicScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in logarithmicScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(logarithmicScale.Exponent); + writer.WritePropertyName("factor"u8); + writer.WriteStringValue(logarithmicScale.Factor); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in logarithmicScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(logarithmicScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(logarithmicScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(logarithmicScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(logarithmicScale.IsMinimumInclusive); + writer.WritePropertyName("logarithmBase"u8); + writer.WriteStringValue(logarithmicScale.LogarithmBase.ToString()); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in logarithmicScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(mappingToReferenceScaleItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(logarithmicScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(logarithmicScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(logarithmicScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(logarithmicScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(logarithmicScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(logarithmicScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(logarithmicScale.PositiveValueConnotation); + writer.WritePropertyName("referenceQuantityKind"u8); + writer.WriteStringValue(logarithmicScale.ReferenceQuantityKind); + writer.WriteStartArray("referenceQuantityValue"u8); + + foreach(var referenceQuantityValueItem in logarithmicScale.ReferenceQuantityValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referenceQuantityValueItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(logarithmicScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(logarithmicScale.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(logarithmicScale.ThingPreference); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(logarithmicScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in logarithmicScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueDefinitionItem); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing LogarithmicScale for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(logarithmicScale.Actor.HasValue) + { + writer.WriteStringValue(logarithmicScale.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in logarithmicScale.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(logarithmicScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in logarithmicScale.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in logarithmicScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in logarithmicScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(logarithmicScale.Exponent); + writer.WritePropertyName("factor"u8); + writer.WriteStringValue(logarithmicScale.Factor); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in logarithmicScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(logarithmicScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(logarithmicScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(logarithmicScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(logarithmicScale.IsMinimumInclusive); + writer.WritePropertyName("logarithmBase"u8); + writer.WriteStringValue(logarithmicScale.LogarithmBase.ToString()); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in logarithmicScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(mappingToReferenceScaleItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(logarithmicScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(logarithmicScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(logarithmicScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(logarithmicScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(logarithmicScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(logarithmicScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(logarithmicScale.PositiveValueConnotation); + writer.WritePropertyName("referenceQuantityKind"u8); + writer.WriteStringValue(logarithmicScale.ReferenceQuantityKind); + writer.WriteStartArray("referenceQuantityValue"u8); + + foreach(var referenceQuantityValueItem in logarithmicScale.ReferenceQuantityValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referenceQuantityValueItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(logarithmicScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(logarithmicScale.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(logarithmicScale.ThingPreference); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(logarithmicScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in logarithmicScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueDefinitionItem); + } + + writer.WriteEndArray(); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/MappingToReferenceScaleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/MappingToReferenceScaleSerializer.cs index 4514063d..f5cc23ee 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/MappingToReferenceScaleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/MappingToReferenceScaleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,165 +49,6 @@ namespace CDP4JsonSerializer /// public class MappingToReferenceScaleSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not MappingToReferenceScale mappingToReferenceScale) - { - throw new ArgumentException("The thing shall be a MappingToReferenceScale", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of MappingToReferenceScale since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing MappingToReferenceScale for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(mappingToReferenceScale.ClassKind.ToString()); - writer.WritePropertyName("dependentScaleValue"u8); - writer.WriteStringValue(mappingToReferenceScale.DependentScaleValue); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(mappingToReferenceScale.Iid); - writer.WritePropertyName("referenceScaleValue"u8); - writer.WriteStringValue(mappingToReferenceScale.ReferenceScaleValue); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(mappingToReferenceScale.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing MappingToReferenceScale for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(mappingToReferenceScale.ClassKind.ToString()); - writer.WritePropertyName("dependentScaleValue"u8); - writer.WriteStringValue(mappingToReferenceScale.DependentScaleValue); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in mappingToReferenceScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in mappingToReferenceScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(mappingToReferenceScale.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(mappingToReferenceScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("referenceScaleValue"u8); - writer.WriteStringValue(mappingToReferenceScale.ReferenceScaleValue); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(mappingToReferenceScale.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing MappingToReferenceScale for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(mappingToReferenceScale.ClassKind.ToString()); - writer.WritePropertyName("dependentScaleValue"u8); - writer.WriteStringValue(mappingToReferenceScale.DependentScaleValue); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in mappingToReferenceScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in mappingToReferenceScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(mappingToReferenceScale.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(mappingToReferenceScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("referenceScaleValue"u8); - writer.WriteStringValue(mappingToReferenceScale.ReferenceScaleValue); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(mappingToReferenceScale.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(mappingToReferenceScale.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing MappingToReferenceScale for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(mappingToReferenceScale.Actor.HasValue) - { - writer.WriteStringValue(mappingToReferenceScale.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(mappingToReferenceScale.ClassKind.ToString()); - writer.WritePropertyName("dependentScaleValue"u8); - writer.WriteStringValue(mappingToReferenceScale.DependentScaleValue); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in mappingToReferenceScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in mappingToReferenceScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(mappingToReferenceScale.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(mappingToReferenceScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("referenceScaleValue"u8); - writer.WriteStringValue(mappingToReferenceScale.ReferenceScaleValue); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(mappingToReferenceScale.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(mappingToReferenceScale.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -216,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -224,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -242,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -260,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "dependentscalevalue": - if(!AllowedVersionsPerProperty["dependentScaleValue"].Contains(requestedVersion)) + var allowedVersionsForDependentScaleValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDependentScaleValue.Contains(requestedVersion)) { return; } @@ -278,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -296,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -314,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -332,7 +214,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -350,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "referencescalevalue": - if(!AllowedVersionsPerProperty["referenceScaleValue"].Contains(requestedVersion)) + var allowedVersionsForReferenceScaleValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReferenceScaleValue.Contains(requestedVersion)) { return; } @@ -368,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -386,7 +291,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -409,21 +320,157 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "dependentScaleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "referenceScaleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not MappingToReferenceScale mappingToReferenceScale) + { + throw new ArgumentException("The thing shall be a MappingToReferenceScale", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of MappingToReferenceScale since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing MappingToReferenceScale for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(mappingToReferenceScale.ClassKind.ToString()); + writer.WritePropertyName("dependentScaleValue"u8); + writer.WriteStringValue(mappingToReferenceScale.DependentScaleValue); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(mappingToReferenceScale.Iid); + writer.WritePropertyName("referenceScaleValue"u8); + writer.WriteStringValue(mappingToReferenceScale.ReferenceScaleValue); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(mappingToReferenceScale.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing MappingToReferenceScale for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(mappingToReferenceScale.ClassKind.ToString()); + writer.WritePropertyName("dependentScaleValue"u8); + writer.WriteStringValue(mappingToReferenceScale.DependentScaleValue); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in mappingToReferenceScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in mappingToReferenceScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(mappingToReferenceScale.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(mappingToReferenceScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("referenceScaleValue"u8); + writer.WriteStringValue(mappingToReferenceScale.ReferenceScaleValue); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(mappingToReferenceScale.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing MappingToReferenceScale for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(mappingToReferenceScale.ClassKind.ToString()); + writer.WritePropertyName("dependentScaleValue"u8); + writer.WriteStringValue(mappingToReferenceScale.DependentScaleValue); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in mappingToReferenceScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in mappingToReferenceScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(mappingToReferenceScale.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(mappingToReferenceScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("referenceScaleValue"u8); + writer.WriteStringValue(mappingToReferenceScale.ReferenceScaleValue); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(mappingToReferenceScale.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(mappingToReferenceScale.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing MappingToReferenceScale for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(mappingToReferenceScale.Actor.HasValue) + { + writer.WriteStringValue(mappingToReferenceScale.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(mappingToReferenceScale.ClassKind.ToString()); + writer.WritePropertyName("dependentScaleValue"u8); + writer.WriteStringValue(mappingToReferenceScale.DependentScaleValue); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in mappingToReferenceScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in mappingToReferenceScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(mappingToReferenceScale.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(mappingToReferenceScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("referenceScaleValue"u8); + writer.WriteStringValue(mappingToReferenceScale.ReferenceScaleValue); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(mappingToReferenceScale.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(mappingToReferenceScale.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ModelLogEntrySerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ModelLogEntrySerializer.cs index e2775bf9..39cf3219 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ModelLogEntrySerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ModelLogEntrySerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,371 +50,288 @@ namespace CDP4JsonSerializer public class ModelLogEntrySerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ModelLogEntry modelLogEntry) - { - throw new ArgumentException("The thing shall be a ModelLogEntry", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ModelLogEntry since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ModelLogEntry for Version 1.0.0"); - writer.WriteStartArray("affectedDomainIid"u8); - - foreach(var affectedDomainIidItem in modelLogEntry.AffectedDomainIid) + case "actor": + var allowedVersionsForActor = new List { - writer.WriteStringValue(affectedDomainIidItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("affectedItemIid"u8); + "1.3.0", + }; - foreach(var affectedItemIidItem in modelLogEntry.AffectedItemIid) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(affectedItemIidItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("author"u8); - - if(modelLogEntry.Author.HasValue) + if(value != null) { - writer.WriteStringValue(modelLogEntry.Author.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("category"u8); + break; + case "affecteddomainiid": + var allowedVersionsForAffectedDomainIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in modelLogEntry.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAffectedDomainIid.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("affectedDomainIid"u8); + + if(value is IEnumerable objectListAffectedDomainIid) + { + foreach(var affectedDomainIidItem in objectListAffectedDomainIid) + { + writer.WriteStringValue((Guid)affectedDomainIidItem); + } + } - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(modelLogEntry.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(modelLogEntry.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(modelLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(modelLogEntry.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(modelLogEntry.LanguageCode); - writer.WritePropertyName("level"u8); - writer.WriteStringValue(modelLogEntry.Level.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(modelLogEntry.RevisionNumber); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ModelLogEntry for Version 1.1.0"); - writer.WriteStartArray("affectedDomainIid"u8); + case "affecteditemiid": + var allowedVersionsForAffectedItemIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var affectedDomainIidItem in modelLogEntry.AffectedDomainIid) + if(!allowedVersionsForAffectedItemIid.Contains(requestedVersion)) { - writer.WriteStringValue(affectedDomainIidItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("affectedItemIid"u8); - foreach(var affectedItemIidItem in modelLogEntry.AffectedItemIid) + if(value is IEnumerable objectListAffectedItemIid) { - writer.WriteStringValue(affectedItemIidItem); + foreach(var affectedItemIidItem in objectListAffectedItemIid) + { + writer.WriteStringValue((Guid)affectedItemIidItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("author"u8); + writer.WriteEndArray(); + break; + case "author": + var allowedVersionsForAuthor = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(modelLogEntry.Author.HasValue) + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { - writer.WriteStringValue(modelLogEntry.Author.Value); + return; + } + + writer.WritePropertyName("author"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in modelLogEntry.Category.OrderBy(x => x, this.GuidComparer)) + break; + case "category": + var allowedVersionsForCategory = new List { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(modelLogEntry.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(modelLogEntry.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(modelLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in modelLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("category"u8); - foreach(var excludedPersonItem in modelLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(excludedPersonItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(modelLogEntry.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(modelLogEntry.LanguageCode); - writer.WritePropertyName("level"u8); - writer.WriteStringValue(modelLogEntry.Level.ToString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(modelLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(modelLogEntry.RevisionNumber); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ModelLogEntry for Version 1.2.0"); - writer.WriteStartArray("affectedDomainIid"u8); - - foreach(var affectedDomainIidItem in modelLogEntry.AffectedDomainIid) + case "classkind": + var allowedVersionsForClassKind = new List { - writer.WriteStringValue(affectedDomainIidItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("affectedItemIid"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var affectedItemIidItem in modelLogEntry.AffectedItemIid) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(affectedItemIidItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("author"u8); - - if(modelLogEntry.Author.HasValue) + if(value != null) { - writer.WriteStringValue(modelLogEntry.Author.Value); + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WriteStartArray("category"u8); + break; + case "content": + var allowedVersionsForContent = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in modelLogEntry.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContent.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(modelLogEntry.ClassKind.ToString()); writer.WritePropertyName("content"u8); - writer.WriteStringValue(modelLogEntry.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(modelLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in modelLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in modelLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(modelLogEntry.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(modelLogEntry.LanguageCode); - writer.WritePropertyName("level"u8); - writer.WriteStringValue(modelLogEntry.Level.ToString()); - writer.WriteStartArray("logEntryChangelogItem"u8); + break; + case "createdon": + var allowedVersionsForCreatedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var logEntryChangelogItemItem in modelLogEntry.LogEntryChangelogItem.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { - writer.WriteStringValue(logEntryChangelogItemItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("createdOn"u8); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(modelLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(modelLogEntry.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(modelLogEntry.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ModelLogEntry for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(modelLogEntry.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(modelLogEntry.Actor.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("affectedDomainIid"u8); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var affectedDomainIidItem in modelLogEntry.AffectedDomainIid) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(affectedDomainIidItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("affectedItemIid"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var affectedItemIidItem in modelLogEntry.AffectedItemIid) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(affectedItemIidItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("author"u8); - - if(modelLogEntry.Author.HasValue) - { - writer.WriteStringValue(modelLogEntry.Author.Value); - } - else + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List { - writer.WriteNullValue(); - } - - writer.WriteStartArray("category"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in modelLogEntry.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(modelLogEntry.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(modelLogEntry.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(modelLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in modelLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in modelLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(modelLogEntry.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(modelLogEntry.LanguageCode); - writer.WritePropertyName("level"u8); - writer.WriteStringValue(modelLogEntry.Level.ToString()); - writer.WriteStartArray("logEntryChangelogItem"u8); - - foreach(var logEntryChangelogItemItem in modelLogEntry.LogEntryChangelogItem.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(logEntryChangelogItemItem); - } - writer.WriteEndArray(); - - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(modelLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(modelLogEntry.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(modelLogEntry.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("iid"u8); if(value != null) { @@ -427,53 +343,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "affecteddomainiid": - if(!AllowedVersionsPerProperty["affectedDomainIid"].Contains(requestedVersion)) + case "languagecode": + var allowedVersionsForLanguageCode = new List { - return; - } - - writer.WriteStartArray("affectedDomainIid"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAffectedDomainIid) + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { - foreach(var affectedDomainIidItem in objectListAffectedDomainIid) - { - writer.WriteStringValue((Guid)affectedDomainIidItem); - } + return; } + + writer.WritePropertyName("languageCode"u8); - writer.WriteEndArray(); - break; - case "affecteditemiid": - if(!AllowedVersionsPerProperty["affectedItemIid"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("affectedItemIid"u8); - - if(value is IEnumerable objectListAffectedItemIid) + else { - foreach(var affectedItemIidItem in objectListAffectedItemIid) - { - writer.WriteStringValue((Guid)affectedItemIidItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + case "level": + var allowedVersionsForLevel = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLevel.Contains(requestedVersion)) { return; } - writer.WritePropertyName("author"u8); + writer.WritePropertyName("level"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((LogLevelKind)value).ToString()); } else { @@ -481,35 +395,48 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "logentrychangelogitem": + var allowedVersionsForLogEntryChangelogItem = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLogEntryChangelogItem.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("logEntryChangelogItem"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListLogEntryChangelogItem) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var logEntryChangelogItemItem in objectListLogEntryChangelogItem.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(logEntryChangelogItemItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -517,17 +444,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("content"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue((int)value); } else { @@ -535,17 +470,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("createdOn"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((string)value); } else { @@ -553,196 +494,335 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ModelLogEntry"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ModelLogEntry modelLogEntry) + { + throw new ArgumentException("The thing shall be a ModelLogEntry", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ModelLogEntry since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ModelLogEntry for Version 1.0.0"); + writer.WriteStartArray("affectedDomainIid"u8); + + foreach(var affectedDomainIidItem in modelLogEntry.AffectedDomainIid) { - return; + writer.WriteStringValue(affectedDomainIidItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WriteStartArray("affectedItemIid"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var affectedItemIidItem in modelLogEntry.AffectedItemIid) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(affectedItemIidItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WritePropertyName("author"u8); + + if(modelLogEntry.Author.HasValue) { - return; + writer.WriteStringValue(modelLogEntry.Author.Value); + } + else + { + writer.WriteNullValue(); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var categoryItem in modelLogEntry.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(modelLogEntry.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(modelLogEntry.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(modelLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(modelLogEntry.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(modelLogEntry.LanguageCode); + writer.WritePropertyName("level"u8); + writer.WriteStringValue(modelLogEntry.Level.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(modelLogEntry.RevisionNumber); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ModelLogEntry for Version 1.1.0"); + writer.WriteStartArray("affectedDomainIid"u8); + + foreach(var affectedDomainIidItem in modelLogEntry.AffectedDomainIid) { - return; + writer.WriteStringValue(affectedDomainIidItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("affectedItemIid"u8); + + foreach(var affectedItemIidItem in modelLogEntry.AffectedItemIid) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(affectedItemIidItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + + if(modelLogEntry.Author.HasValue) + { + writer.WriteStringValue(modelLogEntry.Author.Value); } else { writer.WriteNullValue(); } - break; - case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in modelLogEntry.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("languageCode"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(modelLogEntry.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(modelLogEntry.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(modelLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in modelLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in modelLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(modelLogEntry.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(modelLogEntry.LanguageCode); + writer.WritePropertyName("level"u8); + writer.WriteStringValue(modelLogEntry.Level.ToString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(modelLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(modelLogEntry.RevisionNumber); break; - case "level": - if(!AllowedVersionsPerProperty["level"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ModelLogEntry for Version 1.2.0"); + writer.WriteStartArray("affectedDomainIid"u8); + + foreach(var affectedDomainIidItem in modelLogEntry.AffectedDomainIid) { - return; + writer.WriteStringValue(affectedDomainIidItem); } - writer.WritePropertyName("level"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("affectedItemIid"u8); + + foreach(var affectedItemIidItem in modelLogEntry.AffectedItemIid) { - writer.WriteStringValue(((LogLevelKind)value).ToString()); + writer.WriteStringValue(affectedItemIidItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + + if(modelLogEntry.Author.HasValue) + { + writer.WriteStringValue(modelLogEntry.Author.Value); } else { writer.WriteNullValue(); } - break; - case "logentrychangelogitem": - if(!AllowedVersionsPerProperty["logEntryChangelogItem"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in modelLogEntry.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WriteStartArray("logEntryChangelogItem"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(modelLogEntry.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(modelLogEntry.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(modelLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListLogEntryChangelogItem) + foreach(var excludedDomainItem in modelLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var logEntryChangelogItemItem in objectListLogEntryChangelogItem.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(logEntryChangelogItemItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in modelLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(modelLogEntry.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(modelLogEntry.LanguageCode); + writer.WritePropertyName("level"u8); + writer.WriteStringValue(modelLogEntry.Level.ToString()); + writer.WriteStartArray("logEntryChangelogItem"u8); + + foreach(var logEntryChangelogItemItem in modelLogEntry.LogEntryChangelogItem.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(logEntryChangelogItemItem); + } + + writer.WriteEndArray(); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteStringValue(modelLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(modelLogEntry.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(modelLogEntry.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ModelLogEntry for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(modelLogEntry.Actor.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(modelLogEntry.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteStartArray("affectedDomainIid"u8); + + foreach(var affectedDomainIidItem in modelLogEntry.AffectedDomainIid) { - return; + writer.WriteStringValue(affectedDomainIidItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("affectedItemIid"u8); + + foreach(var affectedItemIidItem in modelLogEntry.AffectedItemIid) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(affectedItemIidItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + + if(modelLogEntry.Author.HasValue) + { + writer.WriteStringValue(modelLogEntry.Author.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in modelLogEntry.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(modelLogEntry.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(modelLogEntry.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(modelLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in modelLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in modelLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(modelLogEntry.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(modelLogEntry.LanguageCode); + writer.WritePropertyName("level"u8); + writer.WriteStringValue(modelLogEntry.Level.ToString()); + writer.WriteStartArray("logEntryChangelogItem"u8); + + foreach(var logEntryChangelogItemItem in modelLogEntry.LogEntryChangelogItem.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(logEntryChangelogItemItem); } + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(modelLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(modelLogEntry.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(modelLogEntry.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ModelLogEntry"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "affectedDomainIid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "affectedItemIid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "author", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "level", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "logEntryChangelogItem", new []{ "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ModelReferenceDataLibrarySerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ModelReferenceDataLibrarySerializer.cs index eb5656fc..adee5fa3 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ModelReferenceDataLibrarySerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ModelReferenceDataLibrarySerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,370 +50,718 @@ namespace CDP4JsonSerializer public class ModelReferenceDataLibrarySerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ModelReferenceDataLibrary modelReferenceDataLibrary) - { - throw new ArgumentException("The thing shall be a ModelReferenceDataLibrary", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.0.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of ModelReferenceDataLibrary since Version is below 1.0.0"); - return; - } + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - writer.WriteStartObject(); + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ModelReferenceDataLibrary for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var aliasItem in modelReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "alias": + var allowedVersionsForAlias = new List { - writer.WriteStringValue(aliasItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WriteStartArray("alias"u8); + + if(value is IEnumerable objectListAlias) + { + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + } - writer.WriteStartArray("baseQuantityKind"u8); + writer.WriteEndArray(); + break; + case "basequantitykind": + var allowedVersionsForBaseQuantityKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var baseQuantityKindItem in modelReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForBaseQuantityKind.Contains(requestedVersion)) { - writer.WriteOrderedItem(baseQuantityKindItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("baseQuantityKind"u8); + + if(value is IEnumerable objectListBaseQuantityKind) + { + foreach(var baseQuantityKindItem in objectListBaseQuantityKind.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(baseQuantityKindItem); + } + } - writer.WriteStartArray("baseUnit"u8); + writer.WriteEndArray(); + break; + case "baseunit": + var allowedVersionsForBaseUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var baseUnitItem in modelReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForBaseUnit.Contains(requestedVersion)) { - writer.WriteStringValue(baseUnitItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("baseUnit"u8); + + if(value is IEnumerable objectListBaseUnit) + { + foreach(var baseUnitItem in objectListBaseUnit.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(baseUnitItem); + } + } - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(modelReferenceDataLibrary.ClassKind.ToString()); - writer.WriteStartArray("constant"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var constantItem in modelReferenceDataLibrary.Constant.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(constantItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("definedCategory"u8); + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } - foreach(var definedCategoryItem in modelReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) + break; + case "constant": + var allowedVersionsForConstant = new List { - writer.WriteStringValue(definedCategoryItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForConstant.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WriteStartArray("constant"u8); + + if(value is IEnumerable objectListConstant) + { + foreach(var constantItem in objectListConstant.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(constantItem); + } + } - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "definedcategory": + var allowedVersionsForDefinedCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in modelReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinedCategory.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("definedCategory"u8); + + if(value is IEnumerable objectListDefinedCategory) + { + foreach(var definedCategoryItem in objectListDefinedCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definedCategoryItem); + } + } - writer.WriteStartArray("fileType"u8); + writer.WriteEndArray(); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var fileTypeItem in modelReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(fileTypeItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); + + if(value is IEnumerable objectListDefinition) + { + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + } - writer.WriteStartArray("glossary"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var glossaryItem in modelReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(glossaryItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in modelReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(modelReferenceDataLibrary.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(modelReferenceDataLibrary.Name); - writer.WriteStartArray("parameterType"u8); + writer.WriteEndArray(); + break; + case "filetype": + var allowedVersionsForFileType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var parameterTypeItem in modelReferenceDataLibrary.ParameterType.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForFileType.Contains(requestedVersion)) { - writer.WriteStringValue(parameterTypeItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("fileType"u8); + + if(value is IEnumerable objectListFileType) + { + foreach(var fileTypeItem in objectListFileType.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileTypeItem); + } + } - writer.WriteStartArray("referenceSource"u8); + writer.WriteEndArray(); + break; + case "glossary": + var allowedVersionsForGlossary = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var referenceSourceItem in modelReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForGlossary.Contains(requestedVersion)) { - writer.WriteStringValue(referenceSourceItem); + return; } + writer.WriteStartArray("glossary"u8); + + if(value is IEnumerable objectListGlossary) + { + foreach(var glossaryItem in objectListGlossary.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(glossaryItem); + } + } + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } - writer.WritePropertyName("requiredRdl"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(modelReferenceDataLibrary.RequiredRdl.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(modelReferenceDataLibrary.RequiredRdl.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(modelReferenceDataLibrary.RevisionNumber); - writer.WriteStartArray("rule"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var ruleItem in modelReferenceDataLibrary.Rule.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(ruleItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("scale"u8); - - foreach(var scaleItem in modelReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(scaleItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(modelReferenceDataLibrary.ShortName); - writer.WriteStartArray("unit"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var unitItem in modelReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(unitItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WriteStartArray("unitPrefix"u8); - - foreach(var unitPrefixItem in modelReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(unitPrefixItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ModelReferenceDataLibrary for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "parametertype": + var allowedVersionsForParameterType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in modelReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForParameterType.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("parameterType"u8); + + if(value is IEnumerable objectListParameterType) + { + foreach(var parameterTypeItem in objectListParameterType.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterTypeItem); + } + } - writer.WriteStartArray("baseQuantityKind"u8); + writer.WriteEndArray(); + break; + case "referencesource": + var allowedVersionsForReferenceSource = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var baseQuantityKindItem in modelReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForReferenceSource.Contains(requestedVersion)) { - writer.WriteOrderedItem(baseQuantityKindItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("referenceSource"u8); + + if(value is IEnumerable objectListReferenceSource) + { + foreach(var referenceSourceItem in objectListReferenceSource.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referenceSourceItem); + } + } - writer.WriteStartArray("baseUnit"u8); + writer.WriteEndArray(); + break; + case "requiredrdl": + var allowedVersionsForRequiredRdl = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var baseUnitItem in modelReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRequiredRdl.Contains(requestedVersion)) { - writer.WriteStringValue(baseUnitItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("requiredRdl"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(modelReferenceDataLibrary.ClassKind.ToString()); - writer.WriteStartArray("constant"u8); - - foreach(var constantItem in modelReferenceDataLibrary.Constant.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(constantItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("definedCategory"u8); + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definedCategoryItem in modelReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - writer.WriteStringValue(definedCategoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in modelReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "rule": + var allowedVersionsForRule = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in modelReferenceDataLibrary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRule.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("rule"u8); - foreach(var excludedPersonItem in modelReferenceDataLibrary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListRule) { - writer.WriteStringValue(excludedPersonItem); + foreach(var ruleItem in objectListRule.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(ruleItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("fileType"u8); + writer.WriteEndArray(); + break; + case "scale": + var allowedVersionsForScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var fileTypeItem in modelReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForScale.Contains(requestedVersion)) { - writer.WriteStringValue(fileTypeItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("glossary"u8); + writer.WriteStartArray("scale"u8); - foreach(var glossaryItem in modelReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListScale) { - writer.WriteStringValue(glossaryItem); + foreach(var scaleItem in objectListScale.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(scaleItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in modelReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(modelReferenceDataLibrary.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(modelReferenceDataLibrary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(modelReferenceDataLibrary.Name); - writer.WriteStartArray("parameterType"u8); - - foreach(var parameterTypeItem in modelReferenceDataLibrary.ParameterType.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(parameterTypeItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("referenceSource"u8); + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; - foreach(var referenceSourceItem in modelReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { - writer.WriteStringValue(referenceSourceItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); - writer.WritePropertyName("requiredRdl"u8); - - if(modelReferenceDataLibrary.RequiredRdl.HasValue) + if(value != null) { - writer.WriteStringValue(modelReferenceDataLibrary.RequiredRdl.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(modelReferenceDataLibrary.RevisionNumber); - writer.WriteStartArray("rule"u8); + break; + case "unit": + var allowedVersionsForUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var ruleItem in modelReferenceDataLibrary.Rule.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForUnit.Contains(requestedVersion)) { - writer.WriteStringValue(ruleItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("scale"u8); + writer.WriteStartArray("unit"u8); - foreach(var scaleItem in modelReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListUnit) { - writer.WriteStringValue(scaleItem); + foreach(var unitItem in objectListUnit.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(unitItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(modelReferenceDataLibrary.ShortName); - writer.WriteStartArray("unit"u8); + writer.WriteEndArray(); + break; + case "unitprefix": + var allowedVersionsForUnitPrefix = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var unitItem in modelReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForUnitPrefix.Contains(requestedVersion)) { - writer.WriteStringValue(unitItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("unitPrefix"u8); - foreach(var unitPrefixItem in modelReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListUnitPrefix) { - writer.WriteStringValue(unitPrefixItem); + foreach(var unitPrefixItem in objectListUnitPrefix.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(unitPrefixItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ModelReferenceDataLibrary for Version 1.2.0"); + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ModelReferenceDataLibrary"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ModelReferenceDataLibrary modelReferenceDataLibrary) + { + throw new ArgumentException("The thing shall be a ModelReferenceDataLibrary", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ModelReferenceDataLibrary since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ModelReferenceDataLibrary for Version 1.0.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in modelReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) @@ -423,7 +770,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("baseQuantityKind"u8); foreach(var baseQuantityKindItem in modelReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) @@ -432,7 +778,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("baseUnit"u8); foreach(var baseUnitItem in modelReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) @@ -441,7 +786,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(modelReferenceDataLibrary.ClassKind.ToString()); writer.WriteStartArray("constant"u8); @@ -452,7 +796,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("definedCategory"u8); foreach(var definedCategoryItem in modelReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) @@ -461,7 +804,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("definition"u8); foreach(var definitionItem in modelReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) @@ -470,25 +812,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in modelReferenceDataLibrary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in modelReferenceDataLibrary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - writer.WriteStartArray("fileType"u8); foreach(var fileTypeItem in modelReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) @@ -497,7 +820,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("glossary"u8); foreach(var glossaryItem in modelReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) @@ -506,7 +828,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in modelReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -515,11 +836,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(modelReferenceDataLibrary.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(modelReferenceDataLibrary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); writer.WriteStringValue(modelReferenceDataLibrary.Name); writer.WriteStartArray("parameterType"u8); @@ -530,7 +848,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("referenceSource"u8); foreach(var referenceSourceItem in modelReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) @@ -539,7 +856,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("requiredRdl"u8); if(modelReferenceDataLibrary.RequiredRdl.HasValue) @@ -561,7 +877,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("scale"u8); foreach(var scaleItem in modelReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) @@ -570,11 +885,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("shortName"u8); writer.WriteStringValue(modelReferenceDataLibrary.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(modelReferenceDataLibrary.ThingPreference); writer.WriteStartArray("unit"u8); foreach(var unitItem in modelReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) @@ -583,7 +895,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("unitPrefix"u8); foreach(var unitPrefixItem in modelReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) @@ -592,21 +903,9 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ModelReferenceDataLibrary for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(modelReferenceDataLibrary.Actor.HasValue) - { - writer.WriteStringValue(modelReferenceDataLibrary.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ModelReferenceDataLibrary for Version 1.1.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in modelReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) @@ -615,7 +914,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("baseQuantityKind"u8); foreach(var baseQuantityKindItem in modelReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) @@ -624,7 +922,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("baseUnit"u8); foreach(var baseUnitItem in modelReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) @@ -633,7 +930,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(modelReferenceDataLibrary.ClassKind.ToString()); writer.WriteStartArray("constant"u8); @@ -644,7 +940,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("definedCategory"u8); foreach(var definedCategoryItem in modelReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) @@ -653,7 +948,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("definition"u8); foreach(var definitionItem in modelReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) @@ -662,7 +956,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in modelReferenceDataLibrary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -671,7 +964,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in modelReferenceDataLibrary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -680,7 +972,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("fileType"u8); foreach(var fileTypeItem in modelReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) @@ -689,7 +980,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("glossary"u8); foreach(var glossaryItem in modelReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) @@ -698,7 +988,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in modelReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -707,7 +996,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(modelReferenceDataLibrary.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -722,7 +1010,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("referenceSource"u8); foreach(var referenceSourceItem in modelReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) @@ -731,7 +1018,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("requiredRdl"u8); if(modelReferenceDataLibrary.RequiredRdl.HasValue) @@ -753,7 +1039,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("scale"u8); foreach(var scaleItem in modelReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) @@ -762,11 +1047,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("shortName"u8); writer.WriteStringValue(modelReferenceDataLibrary.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(modelReferenceDataLibrary.ThingPreference); writer.WriteStartArray("unit"u8); foreach(var unitItem in modelReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) @@ -775,7 +1057,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("unitPrefix"u8); foreach(var unitPrefixItem in modelReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) @@ -784,534 +1065,352 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ModelReferenceDataLibrary for Version 1.2.0"); writer.WriteStartArray("alias"u8); - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "basequantitykind": - if(!AllowedVersionsPerProperty["baseQuantityKind"].Contains(requestedVersion)) + foreach(var aliasItem in modelReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } + writer.WriteEndArray(); writer.WriteStartArray("baseQuantityKind"u8); - if(value is IEnumerable objectListBaseQuantityKind) - { - foreach(var baseQuantityKindItem in objectListBaseQuantityKind.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(baseQuantityKindItem); - } - } - - writer.WriteEndArray(); - break; - case "baseunit": - if(!AllowedVersionsPerProperty["baseUnit"].Contains(requestedVersion)) + foreach(var baseQuantityKindItem in modelReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(baseQuantityKindItem); } + writer.WriteEndArray(); writer.WriteStartArray("baseUnit"u8); - if(value is IEnumerable objectListBaseUnit) - { - foreach(var baseUnitItem in objectListBaseUnit.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(baseUnitItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + foreach(var baseUnitItem in modelReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(baseUnitItem); } + writer.WriteEndArray(); writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "constant": - if(!AllowedVersionsPerProperty["constant"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(modelReferenceDataLibrary.ClassKind.ToString()); writer.WriteStartArray("constant"u8); - if(value is IEnumerable objectListConstant) - { - foreach(var constantItem in objectListConstant.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(constantItem); - } - } - - writer.WriteEndArray(); - break; - case "definedcategory": - if(!AllowedVersionsPerProperty["definedCategory"].Contains(requestedVersion)) + foreach(var constantItem in modelReferenceDataLibrary.Constant.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(constantItem); } + writer.WriteEndArray(); writer.WriteStartArray("definedCategory"u8); - if(value is IEnumerable objectListDefinedCategory) - { - foreach(var definedCategoryItem in objectListDefinedCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definedCategoryItem); - } - } - - writer.WriteEndArray(); - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + foreach(var definedCategoryItem in modelReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definedCategoryItem); } + writer.WriteEndArray(); writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + foreach(var definitionItem in modelReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + foreach(var excludedDomainItem in modelReferenceDataLibrary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "filetype": - if(!AllowedVersionsPerProperty["fileType"].Contains(requestedVersion)) + foreach(var excludedPersonItem in modelReferenceDataLibrary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WriteStartArray("fileType"u8); - if(value is IEnumerable objectListFileType) - { - foreach(var fileTypeItem in objectListFileType.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(fileTypeItem); - } - } - - writer.WriteEndArray(); - break; - case "glossary": - if(!AllowedVersionsPerProperty["glossary"].Contains(requestedVersion)) + foreach(var fileTypeItem in modelReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(fileTypeItem); } + writer.WriteEndArray(); writer.WriteStartArray("glossary"u8); - if(value is IEnumerable objectListGlossary) + foreach(var glossaryItem in modelReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) { - foreach(var glossaryItem in objectListGlossary.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(glossaryItem); - } + writer.WriteStringValue(glossaryItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in modelReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(modelReferenceDataLibrary.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(modelReferenceDataLibrary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(modelReferenceDataLibrary.Name); + writer.WriteStartArray("parameterType"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var parameterTypeItem in modelReferenceDataLibrary.ParameterType.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(parameterTypeItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WriteStartArray("referenceSource"u8); + + foreach(var referenceSourceItem in modelReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(referenceSourceItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("requiredRdl"u8); + + if(modelReferenceDataLibrary.RequiredRdl.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(modelReferenceDataLibrary.RequiredRdl.Value); } else { writer.WriteNullValue(); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(modelReferenceDataLibrary.RevisionNumber); + writer.WriteStartArray("rule"u8); + + foreach(var ruleItem in modelReferenceDataLibrary.Rule.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(ruleItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("scale"u8); + + foreach(var scaleItem in modelReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(scaleItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(modelReferenceDataLibrary.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(modelReferenceDataLibrary.ThingPreference); + writer.WriteStartArray("unit"u8); + + foreach(var unitItem in modelReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(unitItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("unitPrefix"u8); + + foreach(var unitPrefixItem in modelReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(unitPrefixItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ModelReferenceDataLibrary for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(modelReferenceDataLibrary.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(modelReferenceDataLibrary.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in modelReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("parameterType"u8); + writer.WriteEndArray(); + writer.WriteStartArray("baseQuantityKind"u8); - if(value is IEnumerable objectListParameterType) + foreach(var baseQuantityKindItem in modelReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) { - foreach(var parameterTypeItem in objectListParameterType.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterTypeItem); - } + writer.WriteOrderedItem(baseQuantityKindItem); } - + writer.WriteEndArray(); - break; - case "referencesource": - if(!AllowedVersionsPerProperty["referenceSource"].Contains(requestedVersion)) + writer.WriteStartArray("baseUnit"u8); + + foreach(var baseUnitItem in modelReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(baseUnitItem); } - writer.WriteStartArray("referenceSource"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(modelReferenceDataLibrary.ClassKind.ToString()); + writer.WriteStartArray("constant"u8); - if(value is IEnumerable objectListReferenceSource) + foreach(var constantItem in modelReferenceDataLibrary.Constant.OrderBy(x => x, this.GuidComparer)) { - foreach(var referenceSourceItem in objectListReferenceSource.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(referenceSourceItem); - } + writer.WriteStringValue(constantItem); } - + writer.WriteEndArray(); - break; - case "requiredrdl": - if(!AllowedVersionsPerProperty["requiredRdl"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("definedCategory"u8); - writer.WritePropertyName("requiredRdl"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + foreach(var definedCategoryItem in modelReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definedCategoryItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else + foreach(var definitionItem in modelReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "rule": - if(!AllowedVersionsPerProperty["rule"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in modelReferenceDataLibrary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WriteStartArray("rule"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListRule) + foreach(var excludedPersonItem in modelReferenceDataLibrary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - foreach(var ruleItem in objectListRule.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(ruleItem); - } + writer.WriteStringValue(excludedPersonItem); } - + writer.WriteEndArray(); - break; - case "scale": - if(!AllowedVersionsPerProperty["scale"].Contains(requestedVersion)) + writer.WriteStartArray("fileType"u8); + + foreach(var fileTypeItem in modelReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(fileTypeItem); } - writer.WriteStartArray("scale"u8); + writer.WriteEndArray(); + writer.WriteStartArray("glossary"u8); - if(value is IEnumerable objectListScale) + foreach(var glossaryItem in modelReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) { - foreach(var scaleItem in objectListScale.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(scaleItem); - } + writer.WriteStringValue(glossaryItem); } - + writer.WriteEndArray(); - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("hyperLink"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) + foreach(var hyperLinkItem in modelReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(modelReferenceDataLibrary.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(modelReferenceDataLibrary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(modelReferenceDataLibrary.Name); + writer.WriteStartArray("parameterType"u8); + + foreach(var parameterTypeItem in modelReferenceDataLibrary.ParameterType.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(parameterTypeItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("referenceSource"u8); + + foreach(var referenceSourceItem in modelReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(referenceSourceItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("requiredRdl"u8); + + if(modelReferenceDataLibrary.RequiredRdl.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(modelReferenceDataLibrary.RequiredRdl.Value); } else { writer.WriteNullValue(); } - break; - case "unit": - if(!AllowedVersionsPerProperty["unit"].Contains(requestedVersion)) + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(modelReferenceDataLibrary.RevisionNumber); + writer.WriteStartArray("rule"u8); + + foreach(var ruleItem in modelReferenceDataLibrary.Rule.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(ruleItem); } - writer.WriteStartArray("unit"u8); + writer.WriteEndArray(); + writer.WriteStartArray("scale"u8); - if(value is IEnumerable objectListUnit) + foreach(var scaleItem in modelReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) { - foreach(var unitItem in objectListUnit.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(unitItem); - } + writer.WriteStringValue(scaleItem); } - + writer.WriteEndArray(); - break; - case "unitprefix": - if(!AllowedVersionsPerProperty["unitPrefix"].Contains(requestedVersion)) + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(modelReferenceDataLibrary.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(modelReferenceDataLibrary.ThingPreference); + writer.WriteStartArray("unit"u8); + + foreach(var unitItem in modelReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(unitItem); } + writer.WriteEndArray(); writer.WriteStartArray("unitPrefix"u8); - if(value is IEnumerable objectListUnitPrefix) + foreach(var unitPrefixItem in modelReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) { - foreach(var unitPrefixItem in objectListUnitPrefix.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(unitPrefixItem); - } + writer.WriteStringValue(unitPrefixItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ModelReferenceDataLibrary"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "baseQuantityKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "baseUnit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "constant", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definedCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fileType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "glossary", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "referenceSource", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "requiredRdl", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "rule", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "scale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "unit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "unitPrefix", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ModellingThingReferenceSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ModellingThingReferenceSerializer.cs index f2c660d0..35e0bb8a 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ModellingThingReferenceSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ModellingThingReferenceSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,152 +49,6 @@ namespace CDP4JsonSerializer /// public class ModellingThingReferenceSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ModellingThingReference modellingThingReference) - { - throw new ArgumentException("The thing shall be a ModellingThingReference", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ModellingThingReference since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ModellingThingReference for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(modellingThingReference.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in modellingThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in modellingThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(modellingThingReference.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(modellingThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("referencedRevisionNumber"u8); - writer.WriteNumberValue(modellingThingReference.ReferencedRevisionNumber); - writer.WritePropertyName("referencedThing"u8); - writer.WriteStringValue(modellingThingReference.ReferencedThing); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(modellingThingReference.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ModellingThingReference for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(modellingThingReference.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in modellingThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in modellingThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(modellingThingReference.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(modellingThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("referencedRevisionNumber"u8); - writer.WriteNumberValue(modellingThingReference.ReferencedRevisionNumber); - writer.WritePropertyName("referencedThing"u8); - writer.WriteStringValue(modellingThingReference.ReferencedThing); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(modellingThingReference.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(modellingThingReference.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ModellingThingReference for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(modellingThingReference.Actor.HasValue) - { - writer.WriteStringValue(modellingThingReference.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(modellingThingReference.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in modellingThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in modellingThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(modellingThingReference.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(modellingThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("referencedRevisionNumber"u8); - writer.WriteNumberValue(modellingThingReference.ReferencedRevisionNumber); - writer.WritePropertyName("referencedThing"u8); - writer.WriteStringValue(modellingThingReference.ReferencedThing); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(modellingThingReference.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(modellingThingReference.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -203,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -211,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -229,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -247,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -265,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -283,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -301,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -319,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "referencedrevisionnumber": - if(!AllowedVersionsPerProperty["referencedRevisionNumber"].Contains(requestedVersion)) + var allowedVersionsForReferencedRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReferencedRevisionNumber.Contains(requestedVersion)) { return; } @@ -337,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "referencedthing": - if(!AllowedVersionsPerProperty["referencedThing"].Contains(requestedVersion)) + var allowedVersionsForReferencedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReferencedThing.Contains(requestedVersion)) { return; } @@ -355,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -373,7 +286,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -396,21 +315,144 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "referencedRevisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "referencedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not ModellingThingReference modellingThingReference) + { + throw new ArgumentException("The thing shall be a ModellingThingReference", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ModellingThingReference since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ModellingThingReference for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(modellingThingReference.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in modellingThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in modellingThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(modellingThingReference.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(modellingThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("referencedRevisionNumber"u8); + writer.WriteNumberValue(modellingThingReference.ReferencedRevisionNumber); + writer.WritePropertyName("referencedThing"u8); + writer.WriteStringValue(modellingThingReference.ReferencedThing); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(modellingThingReference.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ModellingThingReference for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(modellingThingReference.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in modellingThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in modellingThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(modellingThingReference.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(modellingThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("referencedRevisionNumber"u8); + writer.WriteNumberValue(modellingThingReference.ReferencedRevisionNumber); + writer.WritePropertyName("referencedThing"u8); + writer.WriteStringValue(modellingThingReference.ReferencedThing); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(modellingThingReference.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(modellingThingReference.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ModellingThingReference for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(modellingThingReference.Actor.HasValue) + { + writer.WriteStringValue(modellingThingReference.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(modellingThingReference.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in modellingThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in modellingThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(modellingThingReference.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(modellingThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("referencedRevisionNumber"u8); + writer.WriteNumberValue(modellingThingReference.ReferencedRevisionNumber); + writer.WritePropertyName("referencedThing"u8); + writer.WriteStringValue(modellingThingReference.ReferencedThing); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(modellingThingReference.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(modellingThingReference.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/MultiRelationshipRuleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/MultiRelationshipRuleSerializer.cs index b16ada89..d00ea633 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/MultiRelationshipRuleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/MultiRelationshipRuleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,500 +50,231 @@ namespace CDP4JsonSerializer public class MultiRelationshipRuleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not MultiRelationshipRule multiRelationshipRule) - { - throw new ArgumentException("The thing shall be a MultiRelationshipRule", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of MultiRelationshipRule since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing MultiRelationshipRule for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in multiRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(multiRelationshipRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in multiRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in multiRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(multiRelationshipRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(multiRelationshipRule.IsDeprecated); - writer.WritePropertyName("maxRelated"u8); - writer.WriteNumberValue(multiRelationshipRule.MaxRelated); - writer.WritePropertyName("minRelated"u8); - writer.WriteNumberValue(multiRelationshipRule.MinRelated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(multiRelationshipRule.Name); - writer.WriteStartArray("relatedCategory"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var relatedCategoryItem in multiRelationshipRule.RelatedCategory.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(relatedCategoryItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("relationshipCategory"u8); - writer.WriteStringValue(multiRelationshipRule.RelationshipCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(multiRelationshipRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(multiRelationshipRule.ShortName); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing MultiRelationshipRule for Version 1.1.0"); writer.WriteStartArray("alias"u8); - foreach(var aliasItem in multiRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(aliasItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(multiRelationshipRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in multiRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in multiRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in multiRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in multiRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(multiRelationshipRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(multiRelationshipRule.IsDeprecated); - writer.WritePropertyName("maxRelated"u8); - writer.WriteNumberValue(multiRelationshipRule.MaxRelated); - writer.WritePropertyName("minRelated"u8); - writer.WriteNumberValue(multiRelationshipRule.MinRelated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(multiRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(multiRelationshipRule.Name); - writer.WriteStartArray("relatedCategory"u8); + writer.WriteStartArray("definition"u8); - foreach(var relatedCategoryItem in multiRelationshipRule.RelatedCategory.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(relatedCategoryItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("relationshipCategory"u8); - writer.WriteStringValue(multiRelationshipRule.RelationshipCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(multiRelationshipRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(multiRelationshipRule.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing MultiRelationshipRule for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in multiRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(multiRelationshipRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in multiRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in multiRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in multiRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in multiRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(multiRelationshipRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(multiRelationshipRule.IsDeprecated); - writer.WritePropertyName("maxRelated"u8); - writer.WriteNumberValue(multiRelationshipRule.MaxRelated); - writer.WritePropertyName("minRelated"u8); - writer.WriteNumberValue(multiRelationshipRule.MinRelated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(multiRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(multiRelationshipRule.Name); - writer.WriteStartArray("relatedCategory"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var relatedCategoryItem in multiRelationshipRule.RelatedCategory.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(relatedCategoryItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("relationshipCategory"u8); - writer.WriteStringValue(multiRelationshipRule.RelationshipCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(multiRelationshipRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(multiRelationshipRule.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(multiRelationshipRule.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing MultiRelationshipRule for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(multiRelationshipRule.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(multiRelationshipRule.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in multiRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(multiRelationshipRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in multiRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in multiRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in multiRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in multiRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(multiRelationshipRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(multiRelationshipRule.IsDeprecated); - writer.WritePropertyName("maxRelated"u8); - writer.WriteNumberValue(multiRelationshipRule.MaxRelated); - writer.WritePropertyName("minRelated"u8); - writer.WriteNumberValue(multiRelationshipRule.MinRelated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(multiRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(multiRelationshipRule.Name); - writer.WriteStartArray("relatedCategory"u8); - - foreach(var relatedCategoryItem in multiRelationshipRule.RelatedCategory.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedCategoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("relationshipCategory"u8); - writer.WriteStringValue(multiRelationshipRule.RelationshipCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(multiRelationshipRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(multiRelationshipRule.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(multiRelationshipRule.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - writer.WriteNullValue(); - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { return; } @@ -562,7 +292,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "maxrelated": - if(!AllowedVersionsPerProperty["maxRelated"].Contains(requestedVersion)) + var allowedVersionsForMaxRelated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMaxRelated.Contains(requestedVersion)) { return; } @@ -580,7 +318,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "minrelated": - if(!AllowedVersionsPerProperty["minRelated"].Contains(requestedVersion)) + var allowedVersionsForMinRelated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMinRelated.Contains(requestedVersion)) { return; } @@ -598,7 +344,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -616,7 +369,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -634,7 +395,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "relatedcategory": - if(!AllowedVersionsPerProperty["relatedCategory"].Contains(requestedVersion)) + var allowedVersionsForRelatedCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRelatedCategory.Contains(requestedVersion)) { return; } @@ -652,7 +421,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "relationshipcategory": - if(!AllowedVersionsPerProperty["relationshipCategory"].Contains(requestedVersion)) + var allowedVersionsForRelationshipCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRelationshipCategory.Contains(requestedVersion)) { return; } @@ -670,7 +447,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -688,7 +473,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -706,7 +499,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -729,29 +528,317 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "maxRelated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "minRelated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "relatedCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "relationshipCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not MultiRelationshipRule multiRelationshipRule) + { + throw new ArgumentException("The thing shall be a MultiRelationshipRule", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of MultiRelationshipRule since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing MultiRelationshipRule for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in multiRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(multiRelationshipRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in multiRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in multiRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(multiRelationshipRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(multiRelationshipRule.IsDeprecated); + writer.WritePropertyName("maxRelated"u8); + writer.WriteNumberValue(multiRelationshipRule.MaxRelated); + writer.WritePropertyName("minRelated"u8); + writer.WriteNumberValue(multiRelationshipRule.MinRelated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(multiRelationshipRule.Name); + writer.WriteStartArray("relatedCategory"u8); + + foreach(var relatedCategoryItem in multiRelationshipRule.RelatedCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedCategoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("relationshipCategory"u8); + writer.WriteStringValue(multiRelationshipRule.RelationshipCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(multiRelationshipRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(multiRelationshipRule.ShortName); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing MultiRelationshipRule for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in multiRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(multiRelationshipRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in multiRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in multiRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in multiRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in multiRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(multiRelationshipRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(multiRelationshipRule.IsDeprecated); + writer.WritePropertyName("maxRelated"u8); + writer.WriteNumberValue(multiRelationshipRule.MaxRelated); + writer.WritePropertyName("minRelated"u8); + writer.WriteNumberValue(multiRelationshipRule.MinRelated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(multiRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(multiRelationshipRule.Name); + writer.WriteStartArray("relatedCategory"u8); + + foreach(var relatedCategoryItem in multiRelationshipRule.RelatedCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedCategoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("relationshipCategory"u8); + writer.WriteStringValue(multiRelationshipRule.RelationshipCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(multiRelationshipRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(multiRelationshipRule.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing MultiRelationshipRule for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in multiRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(multiRelationshipRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in multiRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in multiRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in multiRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in multiRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(multiRelationshipRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(multiRelationshipRule.IsDeprecated); + writer.WritePropertyName("maxRelated"u8); + writer.WriteNumberValue(multiRelationshipRule.MaxRelated); + writer.WritePropertyName("minRelated"u8); + writer.WriteNumberValue(multiRelationshipRule.MinRelated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(multiRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(multiRelationshipRule.Name); + writer.WriteStartArray("relatedCategory"u8); + + foreach(var relatedCategoryItem in multiRelationshipRule.RelatedCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedCategoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("relationshipCategory"u8); + writer.WriteStringValue(multiRelationshipRule.RelationshipCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(multiRelationshipRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(multiRelationshipRule.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(multiRelationshipRule.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing MultiRelationshipRule for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(multiRelationshipRule.Actor.HasValue) + { + writer.WriteStringValue(multiRelationshipRule.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in multiRelationshipRule.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(multiRelationshipRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in multiRelationshipRule.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in multiRelationshipRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in multiRelationshipRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in multiRelationshipRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(multiRelationshipRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(multiRelationshipRule.IsDeprecated); + writer.WritePropertyName("maxRelated"u8); + writer.WriteNumberValue(multiRelationshipRule.MaxRelated); + writer.WritePropertyName("minRelated"u8); + writer.WriteNumberValue(multiRelationshipRule.MinRelated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(multiRelationshipRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(multiRelationshipRule.Name); + writer.WriteStartArray("relatedCategory"u8); + + foreach(var relatedCategoryItem in multiRelationshipRule.RelatedCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedCategoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("relationshipCategory"u8); + writer.WriteStringValue(multiRelationshipRule.RelationshipCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(multiRelationshipRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(multiRelationshipRule.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(multiRelationshipRule.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/MultiRelationshipSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/MultiRelationshipSerializer.cs index a32f0b23..fb3357b3 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/MultiRelationshipSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/MultiRelationshipSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,260 +49,6 @@ namespace CDP4JsonSerializer /// public class MultiRelationshipSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not MultiRelationship multiRelationship) - { - throw new ArgumentException("The thing shall be a MultiRelationship", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of MultiRelationship since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing MultiRelationship for Version 1.0.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in multiRelationship.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(multiRelationship.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(multiRelationship.Iid); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(multiRelationship.Owner); - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in multiRelationship.RelatedThing.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(multiRelationship.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing MultiRelationship for Version 1.1.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in multiRelationship.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(multiRelationship.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in multiRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in multiRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(multiRelationship.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(multiRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(multiRelationship.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in multiRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterValueItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in multiRelationship.RelatedThing.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(multiRelationship.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing MultiRelationship for Version 1.2.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in multiRelationship.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(multiRelationship.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in multiRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in multiRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(multiRelationship.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(multiRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(multiRelationship.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(multiRelationship.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in multiRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterValueItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in multiRelationship.RelatedThing.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(multiRelationship.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(multiRelationship.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing MultiRelationship for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(multiRelationship.Actor.HasValue) - { - writer.WriteStringValue(multiRelationship.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in multiRelationship.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(multiRelationship.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in multiRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in multiRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(multiRelationship.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(multiRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(multiRelationship.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(multiRelationship.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in multiRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterValueItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in multiRelationship.RelatedThing.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(multiRelationship.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(multiRelationship.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -311,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -319,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -337,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) { return; } @@ -355,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -373,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -391,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -409,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -427,7 +214,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -445,7 +239,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -463,7 +263,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -481,7 +289,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parametervalue": - if(!AllowedVersionsPerProperty["parameterValue"].Contains(requestedVersion)) + var allowedVersionsForParameterValue = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterValue.Contains(requestedVersion)) { return; } @@ -499,7 +314,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "relatedthing": - if(!AllowedVersionsPerProperty["relatedThing"].Contains(requestedVersion)) + var allowedVersionsForRelatedThing = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRelatedThing.Contains(requestedVersion)) { return; } @@ -517,7 +340,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -535,7 +366,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -558,24 +395,241 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterValue", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "relatedThing", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not MultiRelationship multiRelationship) + { + throw new ArgumentException("The thing shall be a MultiRelationship", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of MultiRelationship since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing MultiRelationship for Version 1.0.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in multiRelationship.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(multiRelationship.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(multiRelationship.Iid); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(multiRelationship.Owner); + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in multiRelationship.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(multiRelationship.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing MultiRelationship for Version 1.1.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in multiRelationship.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(multiRelationship.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in multiRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in multiRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(multiRelationship.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(multiRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(multiRelationship.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in multiRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterValueItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in multiRelationship.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(multiRelationship.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing MultiRelationship for Version 1.2.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in multiRelationship.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(multiRelationship.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in multiRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in multiRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(multiRelationship.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(multiRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(multiRelationship.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(multiRelationship.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in multiRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterValueItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in multiRelationship.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(multiRelationship.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(multiRelationship.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing MultiRelationship for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(multiRelationship.Actor.HasValue) + { + writer.WriteStringValue(multiRelationship.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in multiRelationship.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(multiRelationship.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in multiRelationship.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in multiRelationship.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(multiRelationship.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(multiRelationship.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(multiRelationship.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(multiRelationship.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in multiRelationship.ParameterValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterValueItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in multiRelationship.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(multiRelationship.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(multiRelationship.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/NaturalLanguageSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/NaturalLanguageSerializer.cs index f609812e..6c4ddc06 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/NaturalLanguageSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/NaturalLanguageSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,173 +49,6 @@ namespace CDP4JsonSerializer /// public class NaturalLanguageSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not NaturalLanguage naturalLanguage) - { - throw new ArgumentException("The thing shall be a NaturalLanguage", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of NaturalLanguage since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing NaturalLanguage for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(naturalLanguage.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(naturalLanguage.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(naturalLanguage.LanguageCode); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(naturalLanguage.Name); - writer.WritePropertyName("nativeName"u8); - writer.WriteStringValue(naturalLanguage.NativeName); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(naturalLanguage.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing NaturalLanguage for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(naturalLanguage.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in naturalLanguage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in naturalLanguage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(naturalLanguage.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(naturalLanguage.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(naturalLanguage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(naturalLanguage.Name); - writer.WritePropertyName("nativeName"u8); - writer.WriteStringValue(naturalLanguage.NativeName); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(naturalLanguage.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing NaturalLanguage for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(naturalLanguage.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in naturalLanguage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in naturalLanguage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(naturalLanguage.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(naturalLanguage.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(naturalLanguage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(naturalLanguage.Name); - writer.WritePropertyName("nativeName"u8); - writer.WriteStringValue(naturalLanguage.NativeName); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(naturalLanguage.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(naturalLanguage.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing NaturalLanguage for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(naturalLanguage.Actor.HasValue) - { - writer.WriteStringValue(naturalLanguage.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(naturalLanguage.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in naturalLanguage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in naturalLanguage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(naturalLanguage.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(naturalLanguage.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(naturalLanguage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(naturalLanguage.Name); - writer.WritePropertyName("nativeName"u8); - writer.WriteStringValue(naturalLanguage.NativeName); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(naturalLanguage.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(naturalLanguage.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -224,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -232,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -250,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -268,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -286,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -304,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -322,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + var allowedVersionsForLanguageCode = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } @@ -340,7 +214,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -358,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -376,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "nativename": - if(!AllowedVersionsPerProperty["nativeName"].Contains(requestedVersion)) + var allowedVersionsForNativeName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNativeName.Contains(requestedVersion)) { return; } @@ -394,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -412,7 +317,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -435,22 +346,165 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "nativeName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not NaturalLanguage naturalLanguage) + { + throw new ArgumentException("The thing shall be a NaturalLanguage", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of NaturalLanguage since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing NaturalLanguage for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(naturalLanguage.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(naturalLanguage.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(naturalLanguage.LanguageCode); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(naturalLanguage.Name); + writer.WritePropertyName("nativeName"u8); + writer.WriteStringValue(naturalLanguage.NativeName); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(naturalLanguage.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing NaturalLanguage for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(naturalLanguage.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in naturalLanguage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in naturalLanguage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(naturalLanguage.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(naturalLanguage.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(naturalLanguage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(naturalLanguage.Name); + writer.WritePropertyName("nativeName"u8); + writer.WriteStringValue(naturalLanguage.NativeName); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(naturalLanguage.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing NaturalLanguage for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(naturalLanguage.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in naturalLanguage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in naturalLanguage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(naturalLanguage.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(naturalLanguage.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(naturalLanguage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(naturalLanguage.Name); + writer.WritePropertyName("nativeName"u8); + writer.WriteStringValue(naturalLanguage.NativeName); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(naturalLanguage.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(naturalLanguage.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing NaturalLanguage for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(naturalLanguage.Actor.HasValue) + { + writer.WriteStringValue(naturalLanguage.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(naturalLanguage.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in naturalLanguage.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in naturalLanguage.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(naturalLanguage.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(naturalLanguage.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(naturalLanguage.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(naturalLanguage.Name); + writer.WritePropertyName("nativeName"u8); + writer.WriteStringValue(naturalLanguage.NativeName); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(naturalLanguage.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(naturalLanguage.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/NestedElementSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/NestedElementSerializer.cs index ec17d25b..25f580cc 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/NestedElementSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/NestedElementSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,237 +49,6 @@ namespace CDP4JsonSerializer /// public class NestedElementSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not NestedElement nestedElement) - { - throw new ArgumentException("The thing shall be a NestedElement", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of NestedElement since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing NestedElement for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(nestedElement.ClassKind.ToString()); - writer.WriteStartArray("elementUsage"u8); - - foreach(var elementUsageItem in nestedElement.ElementUsage.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(elementUsageItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(nestedElement.Iid); - writer.WritePropertyName("isVolatile"u8); - writer.WriteBooleanValue(nestedElement.IsVolatile); - writer.WriteStartArray("nestedParameter"u8); - - foreach(var nestedParameterItem in nestedElement.NestedParameter.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(nestedParameterItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(nestedElement.RevisionNumber); - writer.WritePropertyName("rootElement"u8); - writer.WriteStringValue(nestedElement.RootElement); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing NestedElement for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(nestedElement.ClassKind.ToString()); - writer.WriteStartArray("elementUsage"u8); - - foreach(var elementUsageItem in nestedElement.ElementUsage.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(elementUsageItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in nestedElement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in nestedElement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(nestedElement.Iid); - writer.WritePropertyName("isVolatile"u8); - writer.WriteBooleanValue(nestedElement.IsVolatile); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(nestedElement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("nestedParameter"u8); - - foreach(var nestedParameterItem in nestedElement.NestedParameter.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(nestedParameterItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(nestedElement.RevisionNumber); - writer.WritePropertyName("rootElement"u8); - writer.WriteStringValue(nestedElement.RootElement); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing NestedElement for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(nestedElement.ClassKind.ToString()); - writer.WriteStartArray("elementUsage"u8); - - foreach(var elementUsageItem in nestedElement.ElementUsage.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(elementUsageItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in nestedElement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in nestedElement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(nestedElement.Iid); - writer.WritePropertyName("isVolatile"u8); - writer.WriteBooleanValue(nestedElement.IsVolatile); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(nestedElement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("nestedParameter"u8); - - foreach(var nestedParameterItem in nestedElement.NestedParameter.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(nestedParameterItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(nestedElement.RevisionNumber); - writer.WritePropertyName("rootElement"u8); - writer.WriteStringValue(nestedElement.RootElement); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(nestedElement.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing NestedElement for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(nestedElement.Actor.HasValue) - { - writer.WriteStringValue(nestedElement.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(nestedElement.ClassKind.ToString()); - writer.WriteStartArray("elementUsage"u8); - - foreach(var elementUsageItem in nestedElement.ElementUsage.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(elementUsageItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in nestedElement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in nestedElement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(nestedElement.Iid); - writer.WritePropertyName("isVolatile"u8); - writer.WriteBooleanValue(nestedElement.IsVolatile); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(nestedElement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("nestedParameter"u8); - - foreach(var nestedParameterItem in nestedElement.NestedParameter.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(nestedParameterItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(nestedElement.RevisionNumber); - writer.WritePropertyName("rootElement"u8); - writer.WriteStringValue(nestedElement.RootElement); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(nestedElement.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -288,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -296,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -314,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -332,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "elementusage": - if(!AllowedVersionsPerProperty["elementUsage"].Contains(requestedVersion)) + var allowedVersionsForElementUsage = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForElementUsage.Contains(requestedVersion)) { return; } @@ -350,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -368,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -386,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -404,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "isvolatile": - if(!AllowedVersionsPerProperty["isVolatile"].Contains(requestedVersion)) + var allowedVersionsForIsVolatile = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsVolatile.Contains(requestedVersion)) { return; } @@ -422,7 +240,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -440,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "nestedparameter": - if(!AllowedVersionsPerProperty["nestedParameter"].Contains(requestedVersion)) + var allowedVersionsForNestedParameter = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNestedParameter.Contains(requestedVersion)) { return; } @@ -458,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -476,7 +317,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "rootelement": - if(!AllowedVersionsPerProperty["rootElement"].Contains(requestedVersion)) + var allowedVersionsForRootElement = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRootElement.Contains(requestedVersion)) { return; } @@ -494,7 +343,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -517,23 +372,221 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "elementUsage", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isVolatile", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "nestedParameter", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "rootElement", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not NestedElement nestedElement) + { + throw new ArgumentException("The thing shall be a NestedElement", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of NestedElement since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing NestedElement for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(nestedElement.ClassKind.ToString()); + writer.WriteStartArray("elementUsage"u8); + + foreach(var elementUsageItem in nestedElement.ElementUsage.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(elementUsageItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(nestedElement.Iid); + writer.WritePropertyName("isVolatile"u8); + writer.WriteBooleanValue(nestedElement.IsVolatile); + writer.WriteStartArray("nestedParameter"u8); + + foreach(var nestedParameterItem in nestedElement.NestedParameter.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(nestedParameterItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(nestedElement.RevisionNumber); + writer.WritePropertyName("rootElement"u8); + writer.WriteStringValue(nestedElement.RootElement); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing NestedElement for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(nestedElement.ClassKind.ToString()); + writer.WriteStartArray("elementUsage"u8); + + foreach(var elementUsageItem in nestedElement.ElementUsage.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(elementUsageItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in nestedElement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in nestedElement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(nestedElement.Iid); + writer.WritePropertyName("isVolatile"u8); + writer.WriteBooleanValue(nestedElement.IsVolatile); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(nestedElement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("nestedParameter"u8); + + foreach(var nestedParameterItem in nestedElement.NestedParameter.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(nestedParameterItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(nestedElement.RevisionNumber); + writer.WritePropertyName("rootElement"u8); + writer.WriteStringValue(nestedElement.RootElement); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing NestedElement for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(nestedElement.ClassKind.ToString()); + writer.WriteStartArray("elementUsage"u8); + + foreach(var elementUsageItem in nestedElement.ElementUsage.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(elementUsageItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in nestedElement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in nestedElement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(nestedElement.Iid); + writer.WritePropertyName("isVolatile"u8); + writer.WriteBooleanValue(nestedElement.IsVolatile); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(nestedElement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("nestedParameter"u8); + + foreach(var nestedParameterItem in nestedElement.NestedParameter.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(nestedParameterItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(nestedElement.RevisionNumber); + writer.WritePropertyName("rootElement"u8); + writer.WriteStringValue(nestedElement.RootElement); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(nestedElement.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing NestedElement for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(nestedElement.Actor.HasValue) + { + writer.WriteStringValue(nestedElement.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(nestedElement.ClassKind.ToString()); + writer.WriteStartArray("elementUsage"u8); + + foreach(var elementUsageItem in nestedElement.ElementUsage.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(elementUsageItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in nestedElement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in nestedElement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(nestedElement.Iid); + writer.WritePropertyName("isVolatile"u8); + writer.WriteBooleanValue(nestedElement.IsVolatile); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(nestedElement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("nestedParameter"u8); + + foreach(var nestedParameterItem in nestedElement.NestedParameter.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(nestedParameterItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(nestedElement.RevisionNumber); + writer.WritePropertyName("rootElement"u8); + writer.WriteStringValue(nestedElement.RootElement); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(nestedElement.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/NestedParameterSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/NestedParameterSerializer.cs index ead62044..a2599bba 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/NestedParameterSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/NestedParameterSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,233 +49,6 @@ namespace CDP4JsonSerializer /// public class NestedParameterSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not NestedParameter nestedParameter) - { - throw new ArgumentException("The thing shall be a NestedParameter", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of NestedParameter since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing NestedParameter for Version 1.0.0"); - writer.WritePropertyName("actualState"u8); - - if(nestedParameter.ActualState.HasValue) - { - writer.WriteStringValue(nestedParameter.ActualState.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("actualValue"u8); - writer.WriteStringValue(nestedParameter.ActualValue); - writer.WritePropertyName("associatedParameter"u8); - writer.WriteStringValue(nestedParameter.AssociatedParameter); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(nestedParameter.ClassKind.ToString()); - writer.WritePropertyName("formula"u8); - writer.WriteStringValue(nestedParameter.Formula); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(nestedParameter.Iid); - writer.WritePropertyName("isVolatile"u8); - writer.WriteBooleanValue(nestedParameter.IsVolatile); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(nestedParameter.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(nestedParameter.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing NestedParameter for Version 1.1.0"); - writer.WritePropertyName("actualState"u8); - - if(nestedParameter.ActualState.HasValue) - { - writer.WriteStringValue(nestedParameter.ActualState.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("actualValue"u8); - writer.WriteStringValue(nestedParameter.ActualValue); - writer.WritePropertyName("associatedParameter"u8); - writer.WriteStringValue(nestedParameter.AssociatedParameter); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(nestedParameter.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in nestedParameter.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in nestedParameter.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("formula"u8); - writer.WriteStringValue(nestedParameter.Formula); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(nestedParameter.Iid); - writer.WritePropertyName("isVolatile"u8); - writer.WriteBooleanValue(nestedParameter.IsVolatile); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(nestedParameter.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(nestedParameter.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(nestedParameter.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing NestedParameter for Version 1.2.0"); - writer.WritePropertyName("actualState"u8); - - if(nestedParameter.ActualState.HasValue) - { - writer.WriteStringValue(nestedParameter.ActualState.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("actualValue"u8); - writer.WriteStringValue(nestedParameter.ActualValue); - writer.WritePropertyName("associatedParameter"u8); - writer.WriteStringValue(nestedParameter.AssociatedParameter); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(nestedParameter.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in nestedParameter.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in nestedParameter.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("formula"u8); - writer.WriteStringValue(nestedParameter.Formula); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(nestedParameter.Iid); - writer.WritePropertyName("isVolatile"u8); - writer.WriteBooleanValue(nestedParameter.IsVolatile); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(nestedParameter.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(nestedParameter.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(nestedParameter.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(nestedParameter.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing NestedParameter for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(nestedParameter.Actor.HasValue) - { - writer.WriteStringValue(nestedParameter.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("actualState"u8); - - if(nestedParameter.ActualState.HasValue) - { - writer.WriteStringValue(nestedParameter.ActualState.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("actualValue"u8); - writer.WriteStringValue(nestedParameter.ActualValue); - writer.WritePropertyName("associatedParameter"u8); - writer.WriteStringValue(nestedParameter.AssociatedParameter); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(nestedParameter.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in nestedParameter.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in nestedParameter.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("formula"u8); - writer.WriteStringValue(nestedParameter.Formula); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(nestedParameter.Iid); - writer.WritePropertyName("isVolatile"u8); - writer.WriteBooleanValue(nestedParameter.IsVolatile); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(nestedParameter.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(nestedParameter.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(nestedParameter.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(nestedParameter.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -284,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -292,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -310,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "actualstate": - if(!AllowedVersionsPerProperty["actualState"].Contains(requestedVersion)) + var allowedVersionsForActualState = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForActualState.Contains(requestedVersion)) { return; } @@ -328,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "actualvalue": - if(!AllowedVersionsPerProperty["actualValue"].Contains(requestedVersion)) + var allowedVersionsForActualValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForActualValue.Contains(requestedVersion)) { return; } @@ -346,7 +138,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "associatedparameter": - if(!AllowedVersionsPerProperty["associatedParameter"].Contains(requestedVersion)) + var allowedVersionsForAssociatedParameter = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAssociatedParameter.Contains(requestedVersion)) { return; } @@ -364,7 +164,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -382,7 +190,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -400,7 +215,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -418,7 +240,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "formula": - if(!AllowedVersionsPerProperty["formula"].Contains(requestedVersion)) + var allowedVersionsForFormula = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFormula.Contains(requestedVersion)) { return; } @@ -436,7 +266,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -454,7 +292,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "isvolatile": - if(!AllowedVersionsPerProperty["isVolatile"].Contains(requestedVersion)) + var allowedVersionsForIsVolatile = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsVolatile.Contains(requestedVersion)) { return; } @@ -472,7 +318,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -490,7 +343,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -508,7 +369,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -526,7 +395,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -549,25 +424,225 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "actualState", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "actualValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "associatedParameter", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "formula", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isVolatile", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not NestedParameter nestedParameter) + { + throw new ArgumentException("The thing shall be a NestedParameter", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of NestedParameter since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing NestedParameter for Version 1.0.0"); + writer.WritePropertyName("actualState"u8); + + if(nestedParameter.ActualState.HasValue) + { + writer.WriteStringValue(nestedParameter.ActualState.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("actualValue"u8); + writer.WriteStringValue(nestedParameter.ActualValue); + writer.WritePropertyName("associatedParameter"u8); + writer.WriteStringValue(nestedParameter.AssociatedParameter); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(nestedParameter.ClassKind.ToString()); + writer.WritePropertyName("formula"u8); + writer.WriteStringValue(nestedParameter.Formula); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(nestedParameter.Iid); + writer.WritePropertyName("isVolatile"u8); + writer.WriteBooleanValue(nestedParameter.IsVolatile); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(nestedParameter.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(nestedParameter.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing NestedParameter for Version 1.1.0"); + writer.WritePropertyName("actualState"u8); + + if(nestedParameter.ActualState.HasValue) + { + writer.WriteStringValue(nestedParameter.ActualState.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("actualValue"u8); + writer.WriteStringValue(nestedParameter.ActualValue); + writer.WritePropertyName("associatedParameter"u8); + writer.WriteStringValue(nestedParameter.AssociatedParameter); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(nestedParameter.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in nestedParameter.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in nestedParameter.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("formula"u8); + writer.WriteStringValue(nestedParameter.Formula); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(nestedParameter.Iid); + writer.WritePropertyName("isVolatile"u8); + writer.WriteBooleanValue(nestedParameter.IsVolatile); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(nestedParameter.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(nestedParameter.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(nestedParameter.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing NestedParameter for Version 1.2.0"); + writer.WritePropertyName("actualState"u8); + + if(nestedParameter.ActualState.HasValue) + { + writer.WriteStringValue(nestedParameter.ActualState.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("actualValue"u8); + writer.WriteStringValue(nestedParameter.ActualValue); + writer.WritePropertyName("associatedParameter"u8); + writer.WriteStringValue(nestedParameter.AssociatedParameter); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(nestedParameter.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in nestedParameter.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in nestedParameter.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("formula"u8); + writer.WriteStringValue(nestedParameter.Formula); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(nestedParameter.Iid); + writer.WritePropertyName("isVolatile"u8); + writer.WriteBooleanValue(nestedParameter.IsVolatile); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(nestedParameter.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(nestedParameter.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(nestedParameter.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(nestedParameter.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing NestedParameter for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(nestedParameter.Actor.HasValue) + { + writer.WriteStringValue(nestedParameter.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("actualState"u8); + + if(nestedParameter.ActualState.HasValue) + { + writer.WriteStringValue(nestedParameter.ActualState.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("actualValue"u8); + writer.WriteStringValue(nestedParameter.ActualValue); + writer.WritePropertyName("associatedParameter"u8); + writer.WriteStringValue(nestedParameter.AssociatedParameter); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(nestedParameter.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in nestedParameter.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in nestedParameter.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("formula"u8); + writer.WriteStringValue(nestedParameter.Formula); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(nestedParameter.Iid); + writer.WritePropertyName("isVolatile"u8); + writer.WriteBooleanValue(nestedParameter.IsVolatile); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(nestedParameter.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(nestedParameter.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(nestedParameter.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(nestedParameter.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/NotExpressionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/NotExpressionSerializer.cs index 31a6ead3..46c14cca 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/NotExpressionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/NotExpressionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,157 +49,6 @@ namespace CDP4JsonSerializer /// public class NotExpressionSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not NotExpression notExpression) - { - throw new ArgumentException("The thing shall be a NotExpression", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of NotExpression since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing NotExpression for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(notExpression.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(notExpression.Iid); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(notExpression.RevisionNumber); - writer.WritePropertyName("term"u8); - writer.WriteStringValue(notExpression.Term); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing NotExpression for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(notExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in notExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in notExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(notExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(notExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(notExpression.RevisionNumber); - writer.WritePropertyName("term"u8); - writer.WriteStringValue(notExpression.Term); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing NotExpression for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(notExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in notExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in notExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(notExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(notExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(notExpression.RevisionNumber); - writer.WritePropertyName("term"u8); - writer.WriteStringValue(notExpression.Term); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(notExpression.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing NotExpression for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(notExpression.Actor.HasValue) - { - writer.WriteStringValue(notExpression.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(notExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in notExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in notExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(notExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(notExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(notExpression.RevisionNumber); - writer.WritePropertyName("term"u8); - writer.WriteStringValue(notExpression.Term); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(notExpression.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -208,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -216,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -234,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -252,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -270,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -288,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -306,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -324,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -342,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "term": - if(!AllowedVersionsPerProperty["term"].Contains(requestedVersion)) + var allowedVersionsForTerm = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTerm.Contains(requestedVersion)) { return; } @@ -360,7 +265,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -383,20 +294,149 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "term", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not NotExpression notExpression) + { + throw new ArgumentException("The thing shall be a NotExpression", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of NotExpression since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing NotExpression for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(notExpression.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(notExpression.Iid); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(notExpression.RevisionNumber); + writer.WritePropertyName("term"u8); + writer.WriteStringValue(notExpression.Term); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing NotExpression for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(notExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in notExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in notExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(notExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(notExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(notExpression.RevisionNumber); + writer.WritePropertyName("term"u8); + writer.WriteStringValue(notExpression.Term); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing NotExpression for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(notExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in notExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in notExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(notExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(notExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(notExpression.RevisionNumber); + writer.WritePropertyName("term"u8); + writer.WriteStringValue(notExpression.Term); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(notExpression.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing NotExpression for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(notExpression.Actor.HasValue) + { + writer.WriteStringValue(notExpression.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(notExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in notExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in notExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(notExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(notExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(notExpression.RevisionNumber); + writer.WritePropertyName("term"u8); + writer.WriteStringValue(notExpression.Term); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(notExpression.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/OptionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/OptionSerializer.cs index 7090d29f..2dbb091a 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/OptionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/OptionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,369 +50,343 @@ namespace CDP4JsonSerializer public class OptionSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not Option option) - { - throw new ArgumentException("The thing shall be a Option", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Option since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Option for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in option.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in option.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(option.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in option.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in option.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(option.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(option.Name); - writer.WriteStartArray("nestedElement"u8); + writer.WriteStartArray("alias"u8); - foreach(var nestedElementItem in option.NestedElement.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(nestedElementItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(option.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(option.ShortName); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Option for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in option.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in option.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(option.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in option.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in option.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in option.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in option.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(option.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(option.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(option.Name); - writer.WriteStartArray("nestedElement"u8); + writer.WriteStartArray("definition"u8); - foreach(var nestedElementItem in option.NestedElement.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(nestedElementItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(option.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(option.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Option for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in option.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in option.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(option.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in option.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in option.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in option.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in option.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(option.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(option.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(option.Name); - writer.WriteStartArray("nestedElement"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var nestedElementItem in option.NestedElement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(nestedElementItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(option.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(option.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(option.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Option for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(option.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(option.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in option.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in option.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(option.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in option.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in option.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in option.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "nestedelement": + var allowedVersionsForNestedElement = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in option.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForNestedElement.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(option.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(option.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(option.Name); writer.WriteStartArray("nestedElement"u8); - foreach(var nestedElementItem in option.NestedElement.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListNestedElement) { - writer.WriteStringValue(nestedElementItem); + foreach(var nestedElementItem in objectListNestedElement.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(nestedElementItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(option.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(option.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(option.ThingPreference); + writer.WriteEndArray(); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -421,53 +394,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + return; } + + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + else { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -475,230 +444,323 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the Option"); + } + } - writer.WriteStartArray("definition"u8); + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not Option option) + { + throw new ArgumentException("The thing shall be a Option", nameof(thing)); + } - if(value is IEnumerable objectListDefinition) + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Option since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Option for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in option.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in option.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(option.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var definitionItem in option.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in option.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(option.Iid); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(option.Name); + writer.WriteStartArray("nestedElement"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var nestedElementItem in option.NestedElement.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(nestedElementItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(option.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(option.ShortName); break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Option for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in option.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var categoryItem in option.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(option.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in option.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in option.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in option.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in option.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(option.Iid); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteStringValue(option.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(option.Name); + writer.WriteStartArray("nestedElement"u8); + + foreach(var nestedElementItem in option.NestedElement.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(nestedElementItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(option.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(option.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Option for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in option.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(aliasItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in option.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(option.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in option.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in option.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "nestedelement": - if(!AllowedVersionsPerProperty["nestedElement"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in option.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WriteStartArray("nestedElement"u8); + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListNestedElement) + foreach(var hyperLinkItem in option.HyperLink.OrderBy(x => x, this.GuidComparer)) { - foreach(var nestedElementItem in objectListNestedElement.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(nestedElementItem); - } + writer.WriteStringValue(hyperLinkItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(option.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(option.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(option.Name); + writer.WriteStartArray("nestedElement"u8); + + foreach(var nestedElementItem in option.NestedElement.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(nestedElementItem); } + writer.WriteEndArray(); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(option.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(option.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(option.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Option for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(option.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(option.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in option.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in option.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(option.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in option.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in option.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in option.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in option.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(option.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(option.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(option.Name); + writer.WriteStartArray("nestedElement"u8); + + foreach(var nestedElementItem in option.NestedElement.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(nestedElementItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(option.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(option.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(option.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the Option"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "nestedElement", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/OrExpressionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/OrExpressionSerializer.cs index 5cd8ddfb..923a1867 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/OrExpressionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/OrExpressionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,185 +49,6 @@ namespace CDP4JsonSerializer /// public class OrExpressionSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not OrExpression orExpression) - { - throw new ArgumentException("The thing shall be a OrExpression", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of OrExpression since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing OrExpression for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(orExpression.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(orExpression.Iid); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(orExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in orExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing OrExpression for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(orExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in orExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in orExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(orExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(orExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(orExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in orExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing OrExpression for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(orExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in orExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in orExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(orExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(orExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(orExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in orExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(orExpression.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing OrExpression for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(orExpression.Actor.HasValue) - { - writer.WriteStringValue(orExpression.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(orExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in orExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in orExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(orExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(orExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(orExpression.RevisionNumber); - writer.WriteStartArray("term"u8); - - foreach(var termItem in orExpression.Term.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(termItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(orExpression.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -236,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -244,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -262,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -280,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -298,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -316,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -334,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -352,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -370,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "term": - if(!AllowedVersionsPerProperty["term"].Contains(requestedVersion)) + var allowedVersionsForTerm = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTerm.Contains(requestedVersion)) { return; } @@ -388,7 +265,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -411,20 +294,173 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "term", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not OrExpression orExpression) + { + throw new ArgumentException("The thing shall be a OrExpression", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of OrExpression since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing OrExpression for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(orExpression.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(orExpression.Iid); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(orExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in orExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing OrExpression for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(orExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in orExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in orExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(orExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(orExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(orExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in orExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing OrExpression for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(orExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in orExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in orExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(orExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(orExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(orExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in orExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(orExpression.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing OrExpression for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(orExpression.Actor.HasValue) + { + writer.WriteStringValue(orExpression.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(orExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in orExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in orExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(orExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(orExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(orExpression.RevisionNumber); + writer.WriteStartArray("term"u8); + + foreach(var termItem in orExpression.Term.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(termItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(orExpression.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/OrdinalScaleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/OrdinalScaleSerializer.cs index 33ee7da5..621dc57a 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/OrdinalScaleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/OrdinalScaleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,449 +50,292 @@ namespace CDP4JsonSerializer public class OrdinalScaleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not OrdinalScale ordinalScale) - { - throw new ArgumentException("The thing shall be a OrdinalScale", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of OrdinalScale since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing OrdinalScale for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in ordinalScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ordinalScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in ordinalScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in ordinalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ordinalScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(ordinalScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(ordinalScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(ordinalScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var mappingToReferenceScaleItem in ordinalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(mappingToReferenceScaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(ordinalScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(ordinalScale.MinimumPermissibleValue); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ordinalScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(ordinalScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(ordinalScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(ordinalScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ordinalScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ordinalScale.ShortName); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(ordinalScale.Unit); - writer.WritePropertyName("useShortNameValues"u8); - writer.WriteBooleanValue(ordinalScale.UseShortNameValues); - writer.WriteStartArray("valueDefinition"u8); + writer.WriteStartArray("alias"u8); - foreach(var valueDefinitionItem in ordinalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(valueDefinitionItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing OrdinalScale for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in ordinalScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ordinalScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in ordinalScale.Definition.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in ordinalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in ordinalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in ordinalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ordinalScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(ordinalScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(ordinalScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(ordinalScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var mappingToReferenceScaleItem in ordinalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(mappingToReferenceScaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(ordinalScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(ordinalScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ordinalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ordinalScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(ordinalScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(ordinalScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(ordinalScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ordinalScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ordinalScale.ShortName); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(ordinalScale.Unit); - writer.WritePropertyName("useShortNameValues"u8); - writer.WriteBooleanValue(ordinalScale.UseShortNameValues); - writer.WriteStartArray("valueDefinition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var valueDefinitionItem in ordinalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(valueDefinitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing OrdinalScale for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in ordinalScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ordinalScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var definitionItem in ordinalScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(definitionItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in ordinalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var excludedPersonItem in ordinalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(excludedPersonItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in ordinalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ordinalScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(ordinalScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(ordinalScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(ordinalScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); - - foreach(var mappingToReferenceScaleItem in ordinalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(mappingToReferenceScaleItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(ordinalScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(ordinalScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ordinalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ordinalScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(ordinalScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(ordinalScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(ordinalScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ordinalScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ordinalScale.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(ordinalScale.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(ordinalScale.Unit); - writer.WritePropertyName("useShortNameValues"u8); - writer.WriteBooleanValue(ordinalScale.UseShortNameValues); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in ordinalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueDefinitionItem); - } - - writer.WriteEndArray(); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing OrdinalScale for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(ordinalScale.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(ordinalScale.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in ordinalScale.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ordinalScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in ordinalScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in ordinalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in ordinalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "ismaximuminclusive": + var allowedVersionsForIsMaximumInclusive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in ordinalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsMaximumInclusive.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ordinalScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(ordinalScale.IsDeprecated); writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(ordinalScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(ordinalScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); - - foreach(var mappingToReferenceScaleItem in ordinalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(mappingToReferenceScaleItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(ordinalScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(ordinalScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ordinalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ordinalScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(ordinalScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(ordinalScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(ordinalScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ordinalScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ordinalScale.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(ordinalScale.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(ordinalScale.Unit); - writer.WritePropertyName("useShortNameValues"u8); - writer.WriteBooleanValue(ordinalScale.UseShortNameValues); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in ordinalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(valueDefinitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "isminimuminclusive": + var allowedVersionsForIsMinimumInclusive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForIsMinimumInclusive.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("isMinimumInclusive"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteBooleanValue((bool)value); } else { @@ -501,35 +343,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "mappingtoreferencescale": + var allowedVersionsForMappingToReferenceScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMappingToReferenceScale.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("mappingToReferenceScale"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListMappingToReferenceScale) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var mappingToReferenceScaleItem in objectListMappingToReferenceScale.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteStringValue(mappingToReferenceScaleItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "maximumpermissiblevalue": + var allowedVersionsForMaximumPermissibleValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMaximumPermissibleValue.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("maximumPermissibleValue"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -537,89 +395,102 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "minimumpermissiblevalue": + var allowedVersionsForMinimumPermissibleValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMinimumPermissibleValue.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + writer.WritePropertyName("minimumPermissibleValue"u8); + + if(value != null) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListExcludedDomain) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + return; } + + writer.WritePropertyName("modifiedOn"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) + writer.WritePropertyName("name"u8); + + if(value != null) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + case "negativevalueconnotation": + var allowedVersionsForNegativeValueConnotation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNegativeValueConnotation.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("negativeValueConnotation"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -627,17 +498,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "numberset": + var allowedVersionsForNumberSet = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNumberSet.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isDeprecated"u8); + writer.WritePropertyName("numberSet"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(((NumberSetKind)value).ToString()); } else { @@ -645,17 +524,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "ismaximuminclusive": - if(!AllowedVersionsPerProperty["isMaximumInclusive"].Contains(requestedVersion)) + case "positivevalueconnotation": + var allowedVersionsForPositiveValueConnotation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPositiveValueConnotation.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isMaximumInclusive"u8); + writer.WritePropertyName("positiveValueConnotation"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -663,17 +550,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isminimuminclusive": - if(!AllowedVersionsPerProperty["isMinimumInclusive"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isMinimumInclusive"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteNumberValue((int)value); } else { @@ -681,31 +576,21 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "mappingtoreferencescale": - if(!AllowedVersionsPerProperty["mappingToReferenceScale"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List { - return; - } - - writer.WriteStartArray("mappingToReferenceScale"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListMappingToReferenceScale) - { - foreach(var mappingToReferenceScaleItem in objectListMappingToReferenceScale.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(mappingToReferenceScaleItem); - } - } - - writer.WriteEndArray(); - break; - case "maximumpermissiblevalue": - if(!AllowedVersionsPerProperty["maximumPermissibleValue"].Contains(requestedVersion)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { @@ -717,13 +602,19 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "minimumpermissiblevalue": - if(!AllowedVersionsPerProperty["minimumPermissibleValue"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { @@ -735,17 +626,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "unit": + var allowedVersionsForUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUnit.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); + writer.WritePropertyName("unit"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((Guid)value); } else { @@ -753,17 +652,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + case "useshortnamevalues": + var allowedVersionsForUseShortNameValues = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUseShortNameValues.Contains(requestedVersion)) { return; } - writer.WritePropertyName("name"u8); + writer.WritePropertyName("useShortNameValues"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteBooleanValue((bool)value); } else { @@ -771,204 +678,429 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "negativevalueconnotation": - if(!AllowedVersionsPerProperty["negativeValueConnotation"].Contains(requestedVersion)) + case "valuedefinition": + var allowedVersionsForValueDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueDefinition.Contains(requestedVersion)) { return; } - writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStartArray("valueDefinition"u8); + + if(value is IEnumerable objectListValueDefinition) + { + foreach(var valueDefinitionItem in objectListValueDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueDefinitionItem); + } + } - if(value != null) + writer.WriteEndArray(); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the OrdinalScale"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not OrdinalScale ordinalScale) + { + throw new ArgumentException("The thing shall be a OrdinalScale", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of OrdinalScale since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing OrdinalScale for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in ordinalScale.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ordinalScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in ordinalScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "numberset": - if(!AllowedVersionsPerProperty["numberSet"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in ordinalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("numberSet"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ordinalScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(ordinalScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(ordinalScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(ordinalScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in ordinalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((NumberSetKind)value).ToString()); + writer.WriteStringValue(mappingToReferenceScaleItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(ordinalScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(ordinalScale.MinimumPermissibleValue); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ordinalScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(ordinalScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(ordinalScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(ordinalScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ordinalScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ordinalScale.ShortName); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(ordinalScale.Unit); + writer.WritePropertyName("useShortNameValues"u8); + writer.WriteBooleanValue(ordinalScale.UseShortNameValues); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in ordinalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(valueDefinitionItem); } + writer.WriteEndArray(); break; - case "positivevalueconnotation": - if(!AllowedVersionsPerProperty["positiveValueConnotation"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing OrdinalScale for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in ordinalScale.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("positiveValueConnotation"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ordinalScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in ordinalScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ordinalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ordinalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in ordinalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ordinalScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(ordinalScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(ordinalScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(ordinalScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in ordinalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(mappingToReferenceScaleItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(ordinalScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(ordinalScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ordinalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ordinalScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(ordinalScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(ordinalScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(ordinalScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ordinalScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ordinalScale.ShortName); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(ordinalScale.Unit); + writer.WritePropertyName("useShortNameValues"u8); + writer.WriteBooleanValue(ordinalScale.UseShortNameValues); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in ordinalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(valueDefinitionItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing OrdinalScale for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in ordinalScale.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ordinalScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in ordinalScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ordinalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ordinalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in ordinalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } - break; - case "unit": - if(!AllowedVersionsPerProperty["unit"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ordinalScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(ordinalScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(ordinalScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(ordinalScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in ordinalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(mappingToReferenceScaleItem); } + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(ordinalScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(ordinalScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ordinalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ordinalScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(ordinalScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(ordinalScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(ordinalScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ordinalScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ordinalScale.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(ordinalScale.ThingPreference); writer.WritePropertyName("unit"u8); - - if(value != null) + writer.WriteStringValue(ordinalScale.Unit); + writer.WritePropertyName("useShortNameValues"u8); + writer.WriteBooleanValue(ordinalScale.UseShortNameValues); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in ordinalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(valueDefinitionItem); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing OrdinalScale for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(ordinalScale.Actor.HasValue) + { + writer.WriteStringValue(ordinalScale.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "useshortnamevalues": - if(!AllowedVersionsPerProperty["useShortNameValues"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in ordinalScale.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("useShortNameValues"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ordinalScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in ordinalScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ordinalScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "valuedefinition": - if(!AllowedVersionsPerProperty["valueDefinition"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ordinalScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in ordinalScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ordinalScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(ordinalScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(ordinalScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(ordinalScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in ordinalScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(mappingToReferenceScaleItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(ordinalScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(ordinalScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ordinalScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ordinalScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(ordinalScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(ordinalScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(ordinalScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ordinalScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ordinalScale.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(ordinalScale.ThingPreference); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(ordinalScale.Unit); + writer.WritePropertyName("useShortNameValues"u8); + writer.WriteBooleanValue(ordinalScale.UseShortNameValues); writer.WriteStartArray("valueDefinition"u8); - if(value is IEnumerable objectListValueDefinition) + foreach(var valueDefinitionItem in ordinalScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - foreach(var valueDefinitionItem in objectListValueDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueDefinitionItem); - } + writer.WriteStringValue(valueDefinitionItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the OrdinalScale"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isMaximumInclusive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isMinimumInclusive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "mappingToReferenceScale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "maximumPermissibleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "minimumPermissibleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "negativeValueConnotation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "numberSet", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "positiveValueConnotation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "unit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "useShortNameValues", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "valueDefinition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/OrganizationSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/OrganizationSerializer.cs index 5c96221c..9a6f7b74 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/OrganizationSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/OrganizationSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,173 +49,6 @@ namespace CDP4JsonSerializer /// public class OrganizationSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Organization organization) - { - throw new ArgumentException("The thing shall be a Organization", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Organization since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Organization for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(organization.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(organization.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(organization.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(organization.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(organization.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(organization.ShortName); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Organization for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(organization.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in organization.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in organization.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(organization.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(organization.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(organization.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(organization.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(organization.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(organization.ShortName); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Organization for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(organization.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in organization.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in organization.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(organization.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(organization.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(organization.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(organization.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(organization.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(organization.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(organization.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Organization for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(organization.Actor.HasValue) - { - writer.WriteStringValue(organization.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(organization.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in organization.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in organization.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(organization.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(organization.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(organization.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(organization.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(organization.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(organization.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(organization.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -224,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -232,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -250,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -268,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -286,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -304,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -322,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { return; } @@ -340,7 +214,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -358,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -376,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -394,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -412,7 +317,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -435,22 +346,165 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Organization organization) + { + throw new ArgumentException("The thing shall be a Organization", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Organization since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Organization for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(organization.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(organization.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(organization.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(organization.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(organization.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(organization.ShortName); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Organization for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(organization.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in organization.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in organization.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(organization.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(organization.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(organization.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(organization.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(organization.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(organization.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Organization for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(organization.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in organization.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in organization.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(organization.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(organization.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(organization.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(organization.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(organization.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(organization.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(organization.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Organization for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(organization.Actor.HasValue) + { + writer.WriteStringValue(organization.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(organization.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in organization.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in organization.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(organization.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(organization.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(organization.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(organization.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(organization.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(organization.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(organization.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/OrganizationalParticipantSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/OrganizationalParticipantSerializer.cs index cddea0ce..a5664db1 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/OrganizationalParticipantSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/OrganizationalParticipantSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,115 +49,6 @@ namespace CDP4JsonSerializer /// public class OrganizationalParticipantSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not OrganizationalParticipant organizationalParticipant) - { - throw new ArgumentException("The thing shall be a OrganizationalParticipant", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.2.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of OrganizationalParticipant since Version is below 1.2.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing OrganizationalParticipant for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(organizationalParticipant.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in organizationalParticipant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in organizationalParticipant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(organizationalParticipant.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(organizationalParticipant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("organization"u8); - writer.WriteStringValue(organizationalParticipant.Organization); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(organizationalParticipant.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(organizationalParticipant.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing OrganizationalParticipant for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(organizationalParticipant.Actor.HasValue) - { - writer.WriteStringValue(organizationalParticipant.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(organizationalParticipant.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in organizationalParticipant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in organizationalParticipant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(organizationalParticipant.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(organizationalParticipant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("organization"u8); - writer.WriteStringValue(organizationalParticipant.Organization); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(organizationalParticipant.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(organizationalParticipant.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -166,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -174,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -192,7 +86,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -210,7 +110,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -228,7 +135,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -246,7 +160,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -264,7 +184,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -282,7 +209,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "organization": - if(!AllowedVersionsPerProperty["organization"].Contains(requestedVersion)) + var allowedVersionsForOrganization = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOrganization.Contains(requestedVersion)) { return; } @@ -300,7 +233,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -318,7 +257,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -341,20 +286,109 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "organization", new []{ "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not OrganizationalParticipant organizationalParticipant) + { + throw new ArgumentException("The thing shall be a OrganizationalParticipant", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.2.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of OrganizationalParticipant since Version is below 1.2.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing OrganizationalParticipant for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(organizationalParticipant.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in organizationalParticipant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in organizationalParticipant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(organizationalParticipant.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(organizationalParticipant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("organization"u8); + writer.WriteStringValue(organizationalParticipant.Organization); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(organizationalParticipant.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(organizationalParticipant.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing OrganizationalParticipant for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(organizationalParticipant.Actor.HasValue) + { + writer.WriteStringValue(organizationalParticipant.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(organizationalParticipant.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in organizationalParticipant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in organizationalParticipant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(organizationalParticipant.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(organizationalParticipant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("organization"u8); + writer.WriteStringValue(organizationalParticipant.Organization); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(organizationalParticipant.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(organizationalParticipant.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/OwnedStyleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/OwnedStyleSerializer.cs index a85d891e..ceb91132 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/OwnedStyleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/OwnedStyleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,195 +50,597 @@ namespace CDP4JsonSerializer public class OwnedStyleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not OwnedStyle ownedStyle) - { - throw new ArgumentException("The thing shall be a OwnedStyle", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.1.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of OwnedStyle since Version is below 1.1.0"); - return; - } + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - writer.WriteStartObject(); + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing OwnedStyle for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ownedStyle.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedDomainItem in ownedStyle.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + case "classkind": + var allowedVersionsForClassKind = new List { - writer.WriteStringValue(excludedDomainItem); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedPerson"u8); + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedPersonItem in ownedStyle.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteStringValue(excludedPersonItem); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; } + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } - writer.WritePropertyName("fillColor"u8); + writer.WriteEndArray(); + break; + case "fillcolor": + var allowedVersionsForFillColor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(ownedStyle.FillColor.HasValue) + if(!allowedVersionsForFillColor.Contains(requestedVersion)) { - writer.WriteStringValue(ownedStyle.FillColor.Value); + return; + } + + writer.WritePropertyName("fillColor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fillOpacity"u8); + break; + case "fillopacity": + var allowedVersionsForFillOpacity = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(ownedStyle.FillOpacity.HasValue) + if(!allowedVersionsForFillOpacity.Contains(requestedVersion)) { - writer.WriteNumberValue(ownedStyle.FillOpacity.Value); + return; + } + + writer.WritePropertyName("fillOpacity"u8); + + if(value != null) + { + writer.WriteNumberValue((float)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fontBold"u8); + break; + case "fontbold": + var allowedVersionsForFontBold = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(ownedStyle.FontBold.HasValue) + if(!allowedVersionsForFontBold.Contains(requestedVersion)) { - writer.WriteBooleanValue(ownedStyle.FontBold.Value); + return; + } + + writer.WritePropertyName("fontBold"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fontColor"u8); + break; + case "fontcolor": + var allowedVersionsForFontColor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(ownedStyle.FontColor.HasValue) + if(!allowedVersionsForFontColor.Contains(requestedVersion)) { - writer.WriteStringValue(ownedStyle.FontColor.Value); + return; + } + + writer.WritePropertyName("fontColor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fontItalic"u8); + break; + case "fontitalic": + var allowedVersionsForFontItalic = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(ownedStyle.FontItalic.HasValue) + if(!allowedVersionsForFontItalic.Contains(requestedVersion)) { - writer.WriteBooleanValue(ownedStyle.FontItalic.Value); + return; + } + + writer.WritePropertyName("fontItalic"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } + break; + case "fontname": + var allowedVersionsForFontName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFontName.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("fontName"u8); - writer.WriteStringValue(ownedStyle.FontName); - writer.WritePropertyName("fontSize"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - if(ownedStyle.FontSize.HasValue) + break; + case "fontsize": + var allowedVersionsForFontSize = new List { - writer.WriteNumberValue(ownedStyle.FontSize.Value); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFontSize.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("fontSize"u8); + + if(value != null) + { + writer.WriteNumberValue((float)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fontStrokeThrough"u8); + break; + case "fontstrokethrough": + var allowedVersionsForFontStrokeThrough = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(ownedStyle.FontStrokeThrough.HasValue) + if(!allowedVersionsForFontStrokeThrough.Contains(requestedVersion)) { - writer.WriteBooleanValue(ownedStyle.FontStrokeThrough.Value); + return; + } + + writer.WritePropertyName("fontStrokeThrough"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fontUnderline"u8); + break; + case "fontunderline": + var allowedVersionsForFontUnderline = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(ownedStyle.FontUnderline.HasValue) + if(!allowedVersionsForFontUnderline.Contains(requestedVersion)) { - writer.WriteBooleanValue(ownedStyle.FontUnderline.Value); + return; + } + + writer.WritePropertyName("fontUnderline"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ownedStyle.Iid); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ownedStyle.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "name": + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("name"u8); - writer.WriteStringValue(ownedStyle.Name); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ownedStyle.RevisionNumber); - writer.WritePropertyName("strokeColor"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } - if(ownedStyle.StrokeColor.HasValue) + break; + case "strokecolor": + var allowedVersionsForStrokeColor = new List { - writer.WriteStringValue(ownedStyle.StrokeColor.Value); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStrokeColor.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("strokeColor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } + break; + case "strokeopacity": + var allowedVersionsForStrokeOpacity = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStrokeOpacity.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("strokeOpacity"u8); + + if(value != null) + { + writer.WriteNumberValue((float)value); + } + else + { + writer.WriteNullValue(); + } - if(ownedStyle.StrokeOpacity.HasValue) + break; + case "strokewidth": + var allowedVersionsForStrokeWidth = new List { - writer.WriteNumberValue(ownedStyle.StrokeOpacity.Value); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStrokeWidth.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("strokeWidth"u8); + + if(value != null) + { + writer.WriteNumberValue((float)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("strokeWidth"u8); - - if(ownedStyle.StrokeWidth.HasValue) + break; + case "usedcolor": + var allowedVersionsForUsedColor = new List { - writer.WriteNumberValue(ownedStyle.StrokeWidth.Value); - } - else + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUsedColor.Contains(requestedVersion)) { - writer.WriteNullValue(); + return; } writer.WriteStartArray("usedColor"u8); - foreach(var usedColorItem in ownedStyle.UsedColor.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListUsedColor) { - writer.WriteStringValue(usedColorItem); + foreach(var usedColorItem in objectListUsedColor.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(usedColorItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing OwnedStyle for Version 1.2.0"); + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the OwnedStyle"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not OwnedStyle ownedStyle) + { + throw new ArgumentException("The thing shall be a OwnedStyle", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of OwnedStyle since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing OwnedStyle for Version 1.1.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(ownedStyle.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -250,7 +651,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in ownedStyle.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -259,7 +659,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("fillColor"u8); if(ownedStyle.FillColor.HasValue) @@ -391,8 +790,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNullValue(); } - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(ownedStyle.ThingPreference); writer.WriteStartArray("usedColor"u8); foreach(var usedColorItem in ownedStyle.UsedColor.OrderBy(x => x, this.GuidComparer)) @@ -401,21 +798,9 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing OwnedStyle for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(ownedStyle.Actor.HasValue) - { - writer.WriteStringValue(ownedStyle.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing OwnedStyle for Version 1.2.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(ownedStyle.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -426,7 +811,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in ownedStyle.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -435,7 +819,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("fillColor"u8); if(ownedStyle.FillColor.HasValue) @@ -506,529 +889,257 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WritePropertyName("fontStrokeThrough"u8); - if(ownedStyle.FontStrokeThrough.HasValue) - { - writer.WriteBooleanValue(ownedStyle.FontStrokeThrough.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("fontUnderline"u8); - - if(ownedStyle.FontUnderline.HasValue) - { - writer.WriteBooleanValue(ownedStyle.FontUnderline.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ownedStyle.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ownedStyle.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ownedStyle.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ownedStyle.RevisionNumber); - writer.WritePropertyName("strokeColor"u8); - - if(ownedStyle.StrokeColor.HasValue) - { - writer.WriteStringValue(ownedStyle.StrokeColor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("strokeOpacity"u8); - - if(ownedStyle.StrokeOpacity.HasValue) - { - writer.WriteNumberValue(ownedStyle.StrokeOpacity.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("strokeWidth"u8); - - if(ownedStyle.StrokeWidth.HasValue) - { - writer.WriteNumberValue(ownedStyle.StrokeWidth.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(ownedStyle.ThingPreference); - writer.WriteStartArray("usedColor"u8); - - foreach(var usedColorItem in ownedStyle.UsedColor.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(usedColorItem); - } - - writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "fillcolor": - if(!AllowedVersionsPerProperty["fillColor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("fillColor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "fillopacity": - if(!AllowedVersionsPerProperty["fillOpacity"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("fillOpacity"u8); - - if(value != null) + if(ownedStyle.FontStrokeThrough.HasValue) { - writer.WriteNumberValue((float)value); + writer.WriteBooleanValue(ownedStyle.FontStrokeThrough.Value); } else { writer.WriteNullValue(); } - break; - case "fontbold": - if(!AllowedVersionsPerProperty["fontBold"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontUnderline"u8); - writer.WritePropertyName("fontBold"u8); - - if(value != null) + if(ownedStyle.FontUnderline.HasValue) { - writer.WriteBooleanValue((bool)value); + writer.WriteBooleanValue(ownedStyle.FontUnderline.Value); } else { writer.WriteNullValue(); } - break; - case "fontcolor": - if(!AllowedVersionsPerProperty["fontColor"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ownedStyle.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ownedStyle.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ownedStyle.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ownedStyle.RevisionNumber); + writer.WritePropertyName("strokeColor"u8); - writer.WritePropertyName("fontColor"u8); - - if(value != null) + if(ownedStyle.StrokeColor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(ownedStyle.StrokeColor.Value); } else { writer.WriteNullValue(); } - break; - case "fontitalic": - if(!AllowedVersionsPerProperty["fontItalic"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("strokeOpacity"u8); - writer.WritePropertyName("fontItalic"u8); - - if(value != null) + if(ownedStyle.StrokeOpacity.HasValue) { - writer.WriteBooleanValue((bool)value); + writer.WriteNumberValue(ownedStyle.StrokeOpacity.Value); } else { writer.WriteNullValue(); } - break; - case "fontname": - if(!AllowedVersionsPerProperty["fontName"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("strokeWidth"u8); - writer.WritePropertyName("fontName"u8); - - if(value != null) + if(ownedStyle.StrokeWidth.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue(ownedStyle.StrokeWidth.Value); } else { writer.WriteNullValue(); } - break; - case "fontsize": - if(!AllowedVersionsPerProperty["fontSize"].Contains(requestedVersion)) + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(ownedStyle.ThingPreference); + writer.WriteStartArray("usedColor"u8); + + foreach(var usedColorItem in ownedStyle.UsedColor.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(usedColorItem); } - writer.WritePropertyName("fontSize"u8); - - if(value != null) + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing OwnedStyle for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(ownedStyle.Actor.HasValue) { - writer.WriteNumberValue((float)value); + writer.WriteStringValue(ownedStyle.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "fontstrokethrough": - if(!AllowedVersionsPerProperty["fontStrokeThrough"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ownedStyle.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ownedStyle.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("fontStrokeThrough"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ownedStyle.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("fillColor"u8); + + if(ownedStyle.FillColor.HasValue) + { + writer.WriteStringValue(ownedStyle.FillColor.Value); } else { writer.WriteNullValue(); } - break; - case "fontunderline": - if(!AllowedVersionsPerProperty["fontUnderline"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fillOpacity"u8); - writer.WritePropertyName("fontUnderline"u8); - - if(value != null) + if(ownedStyle.FillOpacity.HasValue) { - writer.WriteBooleanValue((bool)value); + writer.WriteNumberValue(ownedStyle.FillOpacity.Value); } else { writer.WriteNullValue(); } - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontBold"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + if(ownedStyle.FontBold.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteBooleanValue(ownedStyle.FontBold.Value); } else { writer.WriteNullValue(); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontColor"u8); - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + if(ownedStyle.FontColor.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(ownedStyle.FontColor.Value); } else { writer.WriteNullValue(); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontItalic"u8); - writer.WritePropertyName("name"u8); - - if(value != null) + if(ownedStyle.FontItalic.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteBooleanValue(ownedStyle.FontItalic.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontName"u8); + writer.WriteStringValue(ownedStyle.FontName); + writer.WritePropertyName("fontSize"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(ownedStyle.FontSize.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteNumberValue(ownedStyle.FontSize.Value); } else { writer.WriteNullValue(); } - break; - case "strokecolor": - if(!AllowedVersionsPerProperty["strokeColor"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontStrokeThrough"u8); - writer.WritePropertyName("strokeColor"u8); - - if(value != null) + if(ownedStyle.FontStrokeThrough.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteBooleanValue(ownedStyle.FontStrokeThrough.Value); } else { writer.WriteNullValue(); } - break; - case "strokeopacity": - if(!AllowedVersionsPerProperty["strokeOpacity"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontUnderline"u8); - writer.WritePropertyName("strokeOpacity"u8); - - if(value != null) + if(ownedStyle.FontUnderline.HasValue) { - writer.WriteNumberValue((float)value); + writer.WriteBooleanValue(ownedStyle.FontUnderline.Value); } else { writer.WriteNullValue(); } - break; - case "strokewidth": - if(!AllowedVersionsPerProperty["strokeWidth"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ownedStyle.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ownedStyle.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ownedStyle.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ownedStyle.RevisionNumber); + writer.WritePropertyName("strokeColor"u8); - writer.WritePropertyName("strokeWidth"u8); - - if(value != null) + if(ownedStyle.StrokeColor.HasValue) { - writer.WriteNumberValue((float)value); + writer.WriteStringValue(ownedStyle.StrokeColor.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("strokeOpacity"u8); - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + if(ownedStyle.StrokeOpacity.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue(ownedStyle.StrokeOpacity.Value); } else { writer.WriteNullValue(); } - break; - case "usedcolor": - if(!AllowedVersionsPerProperty["usedColor"].Contains(requestedVersion)) + writer.WritePropertyName("strokeWidth"u8); + + if(ownedStyle.StrokeWidth.HasValue) { - return; + writer.WriteNumberValue(ownedStyle.StrokeWidth.Value); + } + else + { + writer.WriteNullValue(); } + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(ownedStyle.ThingPreference); writer.WriteStartArray("usedColor"u8); - if(value is IEnumerable objectListUsedColor) + foreach(var usedColorItem in ownedStyle.UsedColor.OrderBy(x => x, this.GuidComparer)) { - foreach(var usedColorItem in objectListUsedColor.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(usedColorItem); - } + writer.WriteStringValue(usedColorItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the OwnedStyle"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fillColor", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fillOpacity", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontBold", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontColor", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontItalic", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontSize", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontStrokeThrough", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontUnderline", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "strokeColor", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "strokeOpacity", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "strokeWidth", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "usedColor", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/PageSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/PageSerializer.cs index d2820f39..cef6bb6d 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/PageSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/PageSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,218 +49,6 @@ namespace CDP4JsonSerializer /// public class PageSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Page page) - { - throw new ArgumentException("The thing shall be a Page", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Page since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Page for Version 1.1.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in page.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(page.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(page.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in page.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in page.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(page.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(page.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(page.Name); - writer.WriteStartArray("note"u8); - - foreach(var noteItem in page.Note.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(noteItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(page.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(page.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(page.ShortName); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Page for Version 1.2.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in page.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(page.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(page.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in page.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in page.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(page.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(page.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(page.Name); - writer.WriteStartArray("note"u8); - - foreach(var noteItem in page.Note.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(noteItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(page.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(page.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(page.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(page.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Page for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(page.Actor.HasValue) - { - writer.WriteStringValue(page.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in page.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(page.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(page.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in page.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in page.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(page.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(page.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(page.Name); - writer.WriteStartArray("note"u8); - - foreach(var noteItem in page.Note.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(noteItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(page.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(page.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(page.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(page.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -269,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -277,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -295,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) { return; } @@ -313,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -331,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -349,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -367,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -385,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -403,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -421,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -439,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "note": - if(!AllowedVersionsPerProperty["note"].Contains(requestedVersion)) + var allowedVersionsForNote = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNote.Contains(requestedVersion)) { return; } @@ -457,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -475,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -493,7 +361,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -511,7 +386,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -534,25 +415,204 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "note", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Page page) + { + throw new ArgumentException("The thing shall be a Page", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Page since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Page for Version 1.1.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in page.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(page.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(page.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in page.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in page.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(page.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(page.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(page.Name); + writer.WriteStartArray("note"u8); + + foreach(var noteItem in page.Note.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(noteItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(page.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(page.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(page.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Page for Version 1.2.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in page.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(page.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(page.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in page.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in page.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(page.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(page.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(page.Name); + writer.WriteStartArray("note"u8); + + foreach(var noteItem in page.Note.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(noteItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(page.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(page.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(page.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(page.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Page for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(page.Actor.HasValue) + { + writer.WriteStringValue(page.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in page.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(page.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(page.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in page.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in page.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(page.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(page.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(page.Name); + writer.WriteStartArray("note"u8); + + foreach(var noteItem in page.Note.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(noteItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(page.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(page.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(page.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(page.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterGroupSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterGroupSerializer.cs index 81f5146b..d2bb2618 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterGroupSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterGroupSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,201 +49,6 @@ namespace CDP4JsonSerializer /// public class ParameterGroupSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ParameterGroup parameterGroup) - { - throw new ArgumentException("The thing shall be a ParameterGroup", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ParameterGroup since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterGroup for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterGroup.ClassKind.ToString()); - writer.WritePropertyName("containingGroup"u8); - - if(parameterGroup.ContainingGroup.HasValue) - { - writer.WriteStringValue(parameterGroup.ContainingGroup.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterGroup.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(parameterGroup.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterGroup.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterGroup for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterGroup.ClassKind.ToString()); - writer.WritePropertyName("containingGroup"u8); - - if(parameterGroup.ContainingGroup.HasValue) - { - writer.WriteStringValue(parameterGroup.ContainingGroup.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterGroup.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(parameterGroup.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterGroup.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterGroup for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterGroup.ClassKind.ToString()); - writer.WritePropertyName("containingGroup"u8); - - if(parameterGroup.ContainingGroup.HasValue) - { - writer.WriteStringValue(parameterGroup.ContainingGroup.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterGroup.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(parameterGroup.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterGroup.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterGroup.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterGroup for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(parameterGroup.Actor.HasValue) - { - writer.WriteStringValue(parameterGroup.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterGroup.ClassKind.ToString()); - writer.WritePropertyName("containingGroup"u8); - - if(parameterGroup.ContainingGroup.HasValue) - { - writer.WriteStringValue(parameterGroup.ContainingGroup.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterGroup.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(parameterGroup.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterGroup.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterGroup.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -252,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -260,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -278,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -296,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "containinggroup": - if(!AllowedVersionsPerProperty["containingGroup"].Contains(requestedVersion)) + var allowedVersionsForContainingGroup = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContainingGroup.Contains(requestedVersion)) { return; } @@ -314,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -332,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -350,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -368,7 +214,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -386,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -404,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -422,7 +291,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -445,21 +320,193 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "containingGroup", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not ParameterGroup parameterGroup) + { + throw new ArgumentException("The thing shall be a ParameterGroup", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ParameterGroup since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterGroup for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterGroup.ClassKind.ToString()); + writer.WritePropertyName("containingGroup"u8); + + if(parameterGroup.ContainingGroup.HasValue) + { + writer.WriteStringValue(parameterGroup.ContainingGroup.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterGroup.Iid); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(parameterGroup.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterGroup.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterGroup for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterGroup.ClassKind.ToString()); + writer.WritePropertyName("containingGroup"u8); + + if(parameterGroup.ContainingGroup.HasValue) + { + writer.WriteStringValue(parameterGroup.ContainingGroup.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterGroup.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(parameterGroup.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterGroup.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterGroup for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterGroup.ClassKind.ToString()); + writer.WritePropertyName("containingGroup"u8); + + if(parameterGroup.ContainingGroup.HasValue) + { + writer.WriteStringValue(parameterGroup.ContainingGroup.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterGroup.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(parameterGroup.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterGroup.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterGroup.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterGroup for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(parameterGroup.Actor.HasValue) + { + writer.WriteStringValue(parameterGroup.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterGroup.ClassKind.ToString()); + writer.WritePropertyName("containingGroup"u8); + + if(parameterGroup.ContainingGroup.HasValue) + { + writer.WriteStringValue(parameterGroup.ContainingGroup.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterGroup.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(parameterGroup.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterGroup.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterGroup.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterOverrideSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterOverrideSerializer.cs index c3be67cd..7746b5d0 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterOverrideSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterOverrideSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,237 +49,6 @@ namespace CDP4JsonSerializer /// public class ParameterOverrideSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ParameterOverride parameterOverride) - { - throw new ArgumentException("The thing shall be a ParameterOverride", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ParameterOverride since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterOverride for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterOverride.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterOverride.Iid); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(parameterOverride.Owner); - writer.WritePropertyName("parameter"u8); - writer.WriteStringValue(parameterOverride.Parameter); - writer.WriteStartArray("parameterSubscription"u8); - - foreach(var parameterSubscriptionItem in parameterOverride.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterSubscriptionItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterOverride.RevisionNumber); - writer.WriteStartArray("valueSet"u8); - - foreach(var valueSetItem in parameterOverride.ValueSet.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueSetItem); - } - - writer.WriteEndArray(); - - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterOverride for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterOverride.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterOverride.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterOverride.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterOverride.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterOverride.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(parameterOverride.Owner); - writer.WritePropertyName("parameter"u8); - writer.WriteStringValue(parameterOverride.Parameter); - writer.WriteStartArray("parameterSubscription"u8); - - foreach(var parameterSubscriptionItem in parameterOverride.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterSubscriptionItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterOverride.RevisionNumber); - writer.WriteStartArray("valueSet"u8); - - foreach(var valueSetItem in parameterOverride.ValueSet.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueSetItem); - } - - writer.WriteEndArray(); - - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterOverride for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterOverride.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterOverride.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterOverride.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterOverride.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterOverride.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(parameterOverride.Owner); - writer.WritePropertyName("parameter"u8); - writer.WriteStringValue(parameterOverride.Parameter); - writer.WriteStartArray("parameterSubscription"u8); - - foreach(var parameterSubscriptionItem in parameterOverride.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterSubscriptionItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterOverride.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterOverride.ThingPreference); - writer.WriteStartArray("valueSet"u8); - - foreach(var valueSetItem in parameterOverride.ValueSet.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueSetItem); - } - - writer.WriteEndArray(); - - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterOverride for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(parameterOverride.Actor.HasValue) - { - writer.WriteStringValue(parameterOverride.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterOverride.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterOverride.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterOverride.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterOverride.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterOverride.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(parameterOverride.Owner); - writer.WritePropertyName("parameter"u8); - writer.WriteStringValue(parameterOverride.Parameter); - writer.WriteStartArray("parameterSubscription"u8); - - foreach(var parameterSubscriptionItem in parameterOverride.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterSubscriptionItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterOverride.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterOverride.ThingPreference); - writer.WriteStartArray("valueSet"u8); - - foreach(var valueSetItem in parameterOverride.ValueSet.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueSetItem); - } - - writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -288,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -296,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -314,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -332,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -350,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -368,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -386,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -404,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -422,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parameter": - if(!AllowedVersionsPerProperty["parameter"].Contains(requestedVersion)) + var allowedVersionsForParameter = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameter.Contains(requestedVersion)) { return; } @@ -440,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parametersubscription": - if(!AllowedVersionsPerProperty["parameterSubscription"].Contains(requestedVersion)) + var allowedVersionsForParameterSubscription = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterSubscription.Contains(requestedVersion)) { return; } @@ -458,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -476,7 +317,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -494,7 +341,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "valueset": - if(!AllowedVersionsPerProperty["valueSet"].Contains(requestedVersion)) + var allowedVersionsForValueSet = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueSet.Contains(requestedVersion)) { return; } @@ -517,23 +372,221 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameter", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterSubscription", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "valueSet", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not ParameterOverride parameterOverride) + { + throw new ArgumentException("The thing shall be a ParameterOverride", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ParameterOverride since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterOverride for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterOverride.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterOverride.Iid); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(parameterOverride.Owner); + writer.WritePropertyName("parameter"u8); + writer.WriteStringValue(parameterOverride.Parameter); + writer.WriteStartArray("parameterSubscription"u8); + + foreach(var parameterSubscriptionItem in parameterOverride.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterSubscriptionItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterOverride.RevisionNumber); + writer.WriteStartArray("valueSet"u8); + + foreach(var valueSetItem in parameterOverride.ValueSet.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueSetItem); + } + + writer.WriteEndArray(); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterOverride for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterOverride.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterOverride.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterOverride.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterOverride.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterOverride.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(parameterOverride.Owner); + writer.WritePropertyName("parameter"u8); + writer.WriteStringValue(parameterOverride.Parameter); + writer.WriteStartArray("parameterSubscription"u8); + + foreach(var parameterSubscriptionItem in parameterOverride.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterSubscriptionItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterOverride.RevisionNumber); + writer.WriteStartArray("valueSet"u8); + + foreach(var valueSetItem in parameterOverride.ValueSet.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueSetItem); + } + + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterOverride for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterOverride.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterOverride.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterOverride.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterOverride.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterOverride.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(parameterOverride.Owner); + writer.WritePropertyName("parameter"u8); + writer.WriteStringValue(parameterOverride.Parameter); + writer.WriteStartArray("parameterSubscription"u8); + + foreach(var parameterSubscriptionItem in parameterOverride.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterSubscriptionItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterOverride.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterOverride.ThingPreference); + writer.WriteStartArray("valueSet"u8); + + foreach(var valueSetItem in parameterOverride.ValueSet.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueSetItem); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterOverride for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(parameterOverride.Actor.HasValue) + { + writer.WriteStringValue(parameterOverride.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterOverride.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterOverride.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterOverride.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterOverride.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterOverride.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(parameterOverride.Owner); + writer.WritePropertyName("parameter"u8); + writer.WriteStringValue(parameterOverride.Parameter); + writer.WriteStartArray("parameterSubscription"u8); + + foreach(var parameterSubscriptionItem in parameterOverride.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterSubscriptionItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterOverride.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterOverride.ThingPreference); + writer.WriteStartArray("valueSet"u8); + + foreach(var valueSetItem in parameterOverride.ValueSet.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueSetItem); + } + + writer.WriteEndArray(); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterOverrideValueSetSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterOverrideValueSetSerializer.cs index 1c3b8080..2cfd1c47 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterOverrideValueSetSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterOverrideValueSetSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,185 +49,6 @@ namespace CDP4JsonSerializer /// public class ParameterOverrideValueSetSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ParameterOverrideValueSet parameterOverrideValueSet) - { - throw new ArgumentException("The thing shall be a ParameterOverrideValueSet", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ParameterOverrideValueSet since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterOverrideValueSet for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterOverrideValueSet.ClassKind.ToString()); - writer.WriteString("computed"u8, parameterOverrideValueSet.Computed.ToJsonString()); - writer.WriteString("formula"u8, parameterOverrideValueSet.Formula.ToJsonString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterOverrideValueSet.Iid); - writer.WriteString("manual"u8, parameterOverrideValueSet.Manual.ToJsonString()); - writer.WritePropertyName("parameterValueSet"u8); - writer.WriteStringValue(parameterOverrideValueSet.ParameterValueSet); - writer.WriteString("published"u8, parameterOverrideValueSet.Published.ToJsonString()); - writer.WriteString("reference"u8, parameterOverrideValueSet.Reference.ToJsonString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterOverrideValueSet.RevisionNumber); - writer.WritePropertyName("valueSwitch"u8); - writer.WriteStringValue(parameterOverrideValueSet.ValueSwitch.ToString()); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterOverrideValueSet for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterOverrideValueSet.ClassKind.ToString()); - writer.WriteString("computed"u8, parameterOverrideValueSet.Computed.ToJsonString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterOverrideValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterOverrideValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteString("formula"u8, parameterOverrideValueSet.Formula.ToJsonString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterOverrideValueSet.Iid); - writer.WriteString("manual"u8, parameterOverrideValueSet.Manual.ToJsonString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterOverrideValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterValueSet"u8); - writer.WriteStringValue(parameterOverrideValueSet.ParameterValueSet); - writer.WriteString("published"u8, parameterOverrideValueSet.Published.ToJsonString()); - writer.WriteString("reference"u8, parameterOverrideValueSet.Reference.ToJsonString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterOverrideValueSet.RevisionNumber); - writer.WritePropertyName("valueSwitch"u8); - writer.WriteStringValue(parameterOverrideValueSet.ValueSwitch.ToString()); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterOverrideValueSet for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterOverrideValueSet.ClassKind.ToString()); - writer.WriteString("computed"u8, parameterOverrideValueSet.Computed.ToJsonString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterOverrideValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterOverrideValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteString("formula"u8, parameterOverrideValueSet.Formula.ToJsonString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterOverrideValueSet.Iid); - writer.WriteString("manual"u8, parameterOverrideValueSet.Manual.ToJsonString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterOverrideValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterValueSet"u8); - writer.WriteStringValue(parameterOverrideValueSet.ParameterValueSet); - writer.WriteString("published"u8, parameterOverrideValueSet.Published.ToJsonString()); - writer.WriteString("reference"u8, parameterOverrideValueSet.Reference.ToJsonString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterOverrideValueSet.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterOverrideValueSet.ThingPreference); - writer.WritePropertyName("valueSwitch"u8); - writer.WriteStringValue(parameterOverrideValueSet.ValueSwitch.ToString()); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterOverrideValueSet for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(parameterOverrideValueSet.Actor.HasValue) - { - writer.WriteStringValue(parameterOverrideValueSet.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterOverrideValueSet.ClassKind.ToString()); - writer.WriteString("computed"u8, parameterOverrideValueSet.Computed.ToJsonString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterOverrideValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterOverrideValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteString("formula"u8, parameterOverrideValueSet.Formula.ToJsonString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterOverrideValueSet.Iid); - writer.WriteString("manual"u8, parameterOverrideValueSet.Manual.ToJsonString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterOverrideValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterValueSet"u8); - writer.WriteStringValue(parameterOverrideValueSet.ParameterValueSet); - writer.WriteString("published"u8, parameterOverrideValueSet.Published.ToJsonString()); - writer.WriteString("reference"u8, parameterOverrideValueSet.Reference.ToJsonString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterOverrideValueSet.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterOverrideValueSet.ThingPreference); - writer.WritePropertyName("valueSwitch"u8); - writer.WriteStringValue(parameterOverrideValueSet.ValueSwitch.ToString()); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -236,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -244,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -262,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -280,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "computed": - if(!AllowedVersionsPerProperty["computed"].Contains(requestedVersion)) + var allowedVersionsForComputed = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForComputed.Contains(requestedVersion)) { return; } @@ -288,7 +128,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteString("computed"u8, ((ValueArray)value).ToJsonString()); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -306,7 +153,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -324,7 +178,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "formula": - if(!AllowedVersionsPerProperty["formula"].Contains(requestedVersion)) + var allowedVersionsForFormula = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFormula.Contains(requestedVersion)) { return; } @@ -332,7 +194,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteString("formula"u8, ((ValueArray)value).ToJsonString()); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -350,7 +220,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "manual": - if(!AllowedVersionsPerProperty["manual"].Contains(requestedVersion)) + var allowedVersionsForManual = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForManual.Contains(requestedVersion)) { return; } @@ -358,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteString("manual"u8, ((ValueArray)value).ToJsonString()); break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -376,7 +261,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parametervalueset": - if(!AllowedVersionsPerProperty["parameterValueSet"].Contains(requestedVersion)) + var allowedVersionsForParameterValueSet = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterValueSet.Contains(requestedVersion)) { return; } @@ -394,7 +287,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "published": - if(!AllowedVersionsPerProperty["published"].Contains(requestedVersion)) + var allowedVersionsForPublished = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPublished.Contains(requestedVersion)) { return; } @@ -402,7 +303,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteString("published"u8, ((ValueArray)value).ToJsonString()); break; case "reference": - if(!AllowedVersionsPerProperty["reference"].Contains(requestedVersion)) + var allowedVersionsForReference = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReference.Contains(requestedVersion)) { return; } @@ -410,7 +319,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteString("reference"u8, ((ValueArray)value).ToJsonString()); break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -428,7 +345,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -446,7 +369,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "valueswitch": - if(!AllowedVersionsPerProperty["valueSwitch"].Contains(requestedVersion)) + var allowedVersionsForValueSwitch = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueSwitch.Contains(requestedVersion)) { return; } @@ -469,26 +400,177 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "computed", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "formula", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "manual", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterValueSet", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "published", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "reference", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "valueSwitch", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not ParameterOverrideValueSet parameterOverrideValueSet) + { + throw new ArgumentException("The thing shall be a ParameterOverrideValueSet", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ParameterOverrideValueSet since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterOverrideValueSet for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterOverrideValueSet.ClassKind.ToString()); + writer.WriteString("computed"u8, parameterOverrideValueSet.Computed.ToJsonString()); + writer.WriteString("formula"u8, parameterOverrideValueSet.Formula.ToJsonString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterOverrideValueSet.Iid); + writer.WriteString("manual"u8, parameterOverrideValueSet.Manual.ToJsonString()); + writer.WritePropertyName("parameterValueSet"u8); + writer.WriteStringValue(parameterOverrideValueSet.ParameterValueSet); + writer.WriteString("published"u8, parameterOverrideValueSet.Published.ToJsonString()); + writer.WriteString("reference"u8, parameterOverrideValueSet.Reference.ToJsonString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterOverrideValueSet.RevisionNumber); + writer.WritePropertyName("valueSwitch"u8); + writer.WriteStringValue(parameterOverrideValueSet.ValueSwitch.ToString()); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterOverrideValueSet for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterOverrideValueSet.ClassKind.ToString()); + writer.WriteString("computed"u8, parameterOverrideValueSet.Computed.ToJsonString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterOverrideValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterOverrideValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteString("formula"u8, parameterOverrideValueSet.Formula.ToJsonString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterOverrideValueSet.Iid); + writer.WriteString("manual"u8, parameterOverrideValueSet.Manual.ToJsonString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterOverrideValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterValueSet"u8); + writer.WriteStringValue(parameterOverrideValueSet.ParameterValueSet); + writer.WriteString("published"u8, parameterOverrideValueSet.Published.ToJsonString()); + writer.WriteString("reference"u8, parameterOverrideValueSet.Reference.ToJsonString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterOverrideValueSet.RevisionNumber); + writer.WritePropertyName("valueSwitch"u8); + writer.WriteStringValue(parameterOverrideValueSet.ValueSwitch.ToString()); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterOverrideValueSet for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterOverrideValueSet.ClassKind.ToString()); + writer.WriteString("computed"u8, parameterOverrideValueSet.Computed.ToJsonString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterOverrideValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterOverrideValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteString("formula"u8, parameterOverrideValueSet.Formula.ToJsonString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterOverrideValueSet.Iid); + writer.WriteString("manual"u8, parameterOverrideValueSet.Manual.ToJsonString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterOverrideValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterValueSet"u8); + writer.WriteStringValue(parameterOverrideValueSet.ParameterValueSet); + writer.WriteString("published"u8, parameterOverrideValueSet.Published.ToJsonString()); + writer.WriteString("reference"u8, parameterOverrideValueSet.Reference.ToJsonString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterOverrideValueSet.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterOverrideValueSet.ThingPreference); + writer.WritePropertyName("valueSwitch"u8); + writer.WriteStringValue(parameterOverrideValueSet.ValueSwitch.ToString()); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterOverrideValueSet for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(parameterOverrideValueSet.Actor.HasValue) + { + writer.WriteStringValue(parameterOverrideValueSet.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterOverrideValueSet.ClassKind.ToString()); + writer.WriteString("computed"u8, parameterOverrideValueSet.Computed.ToJsonString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterOverrideValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterOverrideValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteString("formula"u8, parameterOverrideValueSet.Formula.ToJsonString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterOverrideValueSet.Iid); + writer.WriteString("manual"u8, parameterOverrideValueSet.Manual.ToJsonString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterOverrideValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterValueSet"u8); + writer.WriteStringValue(parameterOverrideValueSet.ParameterValueSet); + writer.WriteString("published"u8, parameterOverrideValueSet.Published.ToJsonString()); + writer.WriteString("reference"u8, parameterOverrideValueSet.Reference.ToJsonString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterOverrideValueSet.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterOverrideValueSet.ThingPreference); + writer.WritePropertyName("valueSwitch"u8); + writer.WriteStringValue(parameterOverrideValueSet.ValueSwitch.ToString()); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSerializer.cs index edb35c05..e9929f62 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,236 +50,540 @@ namespace CDP4JsonSerializer public class ParameterSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not Parameter parameter) - { - throw new ArgumentException("The thing shall be a Parameter", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.0.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of Parameter since Version is below 1.0.0"); - return; - } + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - writer.WriteStartObject(); + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "allowdifferentownerofoverride": + var allowedVersionsForAllowDifferentOwnerOfOverride = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAllowDifferentOwnerOfOverride.Contains(requestedVersion)) + { + return; + } - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Parameter for Version 1.0.0"); writer.WritePropertyName("allowDifferentOwnerOfOverride"u8); - writer.WriteBooleanValue(parameter.AllowDifferentOwnerOfOverride); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameter.ClassKind.ToString()); - writer.WritePropertyName("expectsOverride"u8); - writer.WriteBooleanValue(parameter.ExpectsOverride); - writer.WritePropertyName("group"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); + } - if(parameter.Group.HasValue) + break; + case "classkind": + var allowedVersionsForClassKind = new List { - writer.WriteStringValue(parameter.Group.Value); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("classKind"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameter.Iid); - writer.WritePropertyName("isOptionDependent"u8); - writer.WriteBooleanValue(parameter.IsOptionDependent); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(parameter.Owner); - writer.WriteStartArray("parameterSubscription"u8); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var parameterSubscriptionItem in parameter.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(parameterSubscriptionItem); + return; } + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(parameter.ParameterType); - writer.WritePropertyName("requestedBy"u8); + writer.WriteEndArray(); + break; + case "expectsoverride": + var allowedVersionsForExpectsOverride = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(parameter.RequestedBy.HasValue) + if(!allowedVersionsForExpectsOverride.Contains(requestedVersion)) { - writer.WriteStringValue(parameter.RequestedBy.Value); + return; + } + + writer.WritePropertyName("expectsOverride"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameter.RevisionNumber); - writer.WritePropertyName("scale"u8); + break; + case "group": + var allowedVersionsForGroup = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(parameter.Scale.HasValue) + if(!allowedVersionsForGroup.Contains(requestedVersion)) { - writer.WriteStringValue(parameter.Scale.Value); + return; + } + + writer.WritePropertyName("group"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("stateDependence"u8); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(parameter.StateDependence.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(parameter.StateDependence.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("valueSet"u8); + break; + case "isoptiondependent": + var allowedVersionsForIsOptionDependent = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var valueSetItem in parameter.ValueSet.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsOptionDependent.Contains(requestedVersion)) { - writer.WriteStringValue(valueSetItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isOptionDependent"u8); + if(value != null) + { + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); + } + break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Parameter for Version 1.1.0"); - writer.WritePropertyName("allowDifferentOwnerOfOverride"u8); - writer.WriteBooleanValue(parameter.AllowDifferentOwnerOfOverride); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameter.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in parameter.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedPersonItem in parameter.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "owner": + var allowedVersionsForOwner = new List { - writer.WriteStringValue(excludedPersonItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("owner"u8); - writer.WritePropertyName("expectsOverride"u8); - writer.WriteBooleanValue(parameter.ExpectsOverride); - writer.WritePropertyName("group"u8); - - if(parameter.Group.HasValue) + if(value != null) { - writer.WriteStringValue(parameter.Group.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameter.Iid); - writer.WritePropertyName("isOptionDependent"u8); - writer.WriteBooleanValue(parameter.IsOptionDependent); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameter.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(parameter.Owner); - writer.WriteStartArray("parameterSubscription"u8); + break; + case "parametersubscription": + var allowedVersionsForParameterSubscription = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var parameterSubscriptionItem in parameter.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForParameterSubscription.Contains(requestedVersion)) { - writer.WriteStringValue(parameterSubscriptionItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("parameterSubscription"u8); + + if(value is IEnumerable objectListParameterSubscription) + { + foreach(var parameterSubscriptionItem in objectListParameterSubscription.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterSubscriptionItem); + } + } + writer.WriteEndArray(); + break; + case "parametertype": + var allowedVersionsForParameterType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterType.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(parameter.ParameterType); - writer.WritePropertyName("requestedBy"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - if(parameter.RequestedBy.HasValue) + break; + case "requestedby": + var allowedVersionsForRequestedBy = new List { - writer.WriteStringValue(parameter.RequestedBy.Value); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRequestedBy.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("requestedBy"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameter.RevisionNumber); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "scale": + var allowedVersionsForScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForScale.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("scale"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "statedependence": + var allowedVersionsForStateDependence = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStateDependence.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("stateDependence"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } - if(parameter.Scale.HasValue) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - writer.WriteStringValue(parameter.Scale.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("stateDependence"u8); - - if(parameter.StateDependence.HasValue) + break; + case "valueset": + var allowedVersionsForValueSet = new List { - writer.WriteStringValue(parameter.StateDependence.Value); - } - else + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueSet.Contains(requestedVersion)) { - writer.WriteNullValue(); + return; } writer.WriteStartArray("valueSet"u8); - foreach(var valueSetItem in parameter.ValueSet.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListValueSet) { - writer.WriteStringValue(valueSetItem); + foreach(var valueSetItem in objectListValueSet.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueSetItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Parameter for Version 1.2.0"); - writer.WritePropertyName("allowDifferentOwnerOfOverride"u8); - writer.WriteBooleanValue(parameter.AllowDifferentOwnerOfOverride); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameter.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the Parameter"); + } + } - foreach(var excludedDomainItem in parameter.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not Parameter parameter) + { + throw new ArgumentException("The thing shall be a Parameter", nameof(thing)); + } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Parameter since Version is below 1.0.0"); + return; + } - foreach(var excludedPersonItem in parameter.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStartObject(); - writer.WriteEndArray(); - + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Parameter for Version 1.0.0"); + writer.WritePropertyName("allowDifferentOwnerOfOverride"u8); + writer.WriteBooleanValue(parameter.AllowDifferentOwnerOfOverride); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameter.ClassKind.ToString()); writer.WritePropertyName("expectsOverride"u8); writer.WriteBooleanValue(parameter.ExpectsOverride); writer.WritePropertyName("group"u8); @@ -298,8 +601,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(parameter.Iid); writer.WritePropertyName("isOptionDependent"u8); writer.WriteBooleanValue(parameter.IsOptionDependent); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameter.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("owner"u8); writer.WriteStringValue(parameter.Owner); writer.WriteStartArray("parameterSubscription"u8); @@ -310,7 +611,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("parameterType"u8); writer.WriteStringValue(parameter.ParameterType); writer.WritePropertyName("requestedBy"u8); @@ -348,8 +648,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNullValue(); } - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameter.ThingPreference); writer.WriteStartArray("valueSet"u8); foreach(var valueSetItem in parameter.ValueSet.OrderBy(x => x, this.GuidComparer)) @@ -358,21 +656,9 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Parameter for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(parameter.Actor.HasValue) - { - writer.WriteStringValue(parameter.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Parameter for Version 1.1.0"); writer.WritePropertyName("allowDifferentOwnerOfOverride"u8); writer.WriteBooleanValue(parameter.AllowDifferentOwnerOfOverride); writer.WritePropertyName("classKind"u8); @@ -385,7 +671,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in parameter.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -394,7 +679,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("expectsOverride"u8); writer.WriteBooleanValue(parameter.ExpectsOverride); writer.WritePropertyName("group"u8); @@ -424,7 +708,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("parameterType"u8); writer.WriteStringValue(parameter.ParameterType); writer.WritePropertyName("requestedBy"u8); @@ -438,435 +721,254 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNullValue(); } - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameter.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(parameter.Scale.HasValue) - { - writer.WriteStringValue(parameter.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("stateDependence"u8); - - if(parameter.StateDependence.HasValue) - { - writer.WriteStringValue(parameter.StateDependence.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameter.ThingPreference); - writer.WriteStartArray("valueSet"u8); - - foreach(var valueSetItem in parameter.ValueSet.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueSetItem); - } - - writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "allowdifferentownerofoverride": - if(!AllowedVersionsPerProperty["allowDifferentOwnerOfOverride"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("allowDifferentOwnerOfOverride"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "expectsoverride": - if(!AllowedVersionsPerProperty["expectsOverride"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("expectsOverride"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "group": - if(!AllowedVersionsPerProperty["group"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameter.RevisionNumber); + writer.WritePropertyName("scale"u8); - writer.WritePropertyName("group"u8); - - if(value != null) + if(parameter.Scale.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(parameter.Scale.Value); } else { writer.WriteNullValue(); } - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("stateDependence"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + if(parameter.StateDependence.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(parameter.StateDependence.Value); } else { writer.WriteNullValue(); } - break; - case "isoptiondependent": - if(!AllowedVersionsPerProperty["isOptionDependent"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("valueSet"u8); - writer.WritePropertyName("isOptionDependent"u8); - - if(value != null) + foreach(var valueSetItem in parameter.ValueSet.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(valueSetItem); } - else + + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Parameter for Version 1.2.0"); + writer.WritePropertyName("allowDifferentOwnerOfOverride"u8); + writer.WriteBooleanValue(parameter.AllowDifferentOwnerOfOverride); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameter.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameter.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameter.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("expectsOverride"u8); + writer.WriteBooleanValue(parameter.ExpectsOverride); + writer.WritePropertyName("group"u8); + + if(parameter.Group.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(parameter.Group.Value); } else { writer.WriteNullValue(); } - break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameter.Iid); + writer.WritePropertyName("isOptionDependent"u8); + writer.WriteBooleanValue(parameter.IsOptionDependent); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameter.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(parameter.Owner); + writer.WriteStartArray("parameterSubscription"u8); + + foreach(var parameterSubscriptionItem in parameter.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(parameterSubscriptionItem); } - writer.WritePropertyName("owner"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(parameter.ParameterType); + writer.WritePropertyName("requestedBy"u8); + + if(parameter.RequestedBy.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(parameter.RequestedBy.Value); } else { writer.WriteNullValue(); } - break; - case "parametersubscription": - if(!AllowedVersionsPerProperty["parameterSubscription"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("parameterSubscription"u8); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameter.RevisionNumber); + writer.WritePropertyName("scale"u8); - if(value is IEnumerable objectListParameterSubscription) + if(parameter.Scale.HasValue) { - foreach(var parameterSubscriptionItem in objectListParameterSubscription.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterSubscriptionItem); - } + writer.WriteStringValue(parameter.Scale.Value); } - - writer.WriteEndArray(); - break; - case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WritePropertyName("parameterType"u8); - - if(value != null) + writer.WritePropertyName("stateDependence"u8); + + if(parameter.StateDependence.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(parameter.StateDependence.Value); } else { writer.WriteNullValue(); } - break; - case "requestedby": - if(!AllowedVersionsPerProperty["requestedBy"].Contains(requestedVersion)) + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameter.ThingPreference); + writer.WriteStartArray("valueSet"u8); + + foreach(var valueSetItem in parameter.ValueSet.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(valueSetItem); } - writer.WritePropertyName("requestedBy"u8); - - if(value != null) + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Parameter for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(parameter.Actor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(parameter.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WritePropertyName("allowDifferentOwnerOfOverride"u8); + writer.WriteBooleanValue(parameter.AllowDifferentOwnerOfOverride); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameter.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameter.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameter.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("expectsOverride"u8); + writer.WriteBooleanValue(parameter.ExpectsOverride); + writer.WritePropertyName("group"u8); + + if(parameter.Group.HasValue) + { + writer.WriteStringValue(parameter.Group.Value); } else { writer.WriteNullValue(); } - break; - case "scale": - if(!AllowedVersionsPerProperty["scale"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameter.Iid); + writer.WritePropertyName("isOptionDependent"u8); + writer.WriteBooleanValue(parameter.IsOptionDependent); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameter.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(parameter.Owner); + writer.WriteStartArray("parameterSubscription"u8); + + foreach(var parameterSubscriptionItem in parameter.ParameterSubscription.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(parameterSubscriptionItem); } - writer.WritePropertyName("scale"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(parameter.ParameterType); + writer.WritePropertyName("requestedBy"u8); + + if(parameter.RequestedBy.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(parameter.RequestedBy.Value); } else { writer.WriteNullValue(); } - break; - case "statedependence": - if(!AllowedVersionsPerProperty["stateDependence"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameter.RevisionNumber); + writer.WritePropertyName("scale"u8); - writer.WritePropertyName("stateDependence"u8); - - if(value != null) + if(parameter.Scale.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(parameter.Scale.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("stateDependence"u8); - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + if(parameter.StateDependence.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(parameter.StateDependence.Value); } else { writer.WriteNullValue(); } - break; - case "valueset": - if(!AllowedVersionsPerProperty["valueSet"].Contains(requestedVersion)) - { - return; - } - + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameter.ThingPreference); writer.WriteStartArray("valueSet"u8); - if(value is IEnumerable objectListValueSet) + foreach(var valueSetItem in parameter.ValueSet.OrderBy(x => x, this.GuidComparer)) { - foreach(var valueSetItem in objectListValueSet.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueSetItem); - } + writer.WriteStringValue(valueSetItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the Parameter"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "allowDifferentOwnerOfOverride", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "expectsOverride", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "group", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isOptionDependent", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterSubscription", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "requestedBy", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "scale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "stateDependence", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "valueSet", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSubscriptionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSubscriptionSerializer.cs index 6832b54a..31ec8338 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSubscriptionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSubscriptionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,193 +49,6 @@ namespace CDP4JsonSerializer /// public class ParameterSubscriptionSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ParameterSubscription parameterSubscription) - { - throw new ArgumentException("The thing shall be a ParameterSubscription", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ParameterSubscription since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterSubscription for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterSubscription.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterSubscription.Iid); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(parameterSubscription.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterSubscription.RevisionNumber); - writer.WriteStartArray("valueSet"u8); - - foreach(var valueSetItem in parameterSubscription.ValueSet.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueSetItem); - } - - writer.WriteEndArray(); - - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterSubscription for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterSubscription.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterSubscription.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterSubscription.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterSubscription.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterSubscription.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(parameterSubscription.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterSubscription.RevisionNumber); - writer.WriteStartArray("valueSet"u8); - - foreach(var valueSetItem in parameterSubscription.ValueSet.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueSetItem); - } - - writer.WriteEndArray(); - - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterSubscription for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterSubscription.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterSubscription.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterSubscription.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterSubscription.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterSubscription.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(parameterSubscription.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterSubscription.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterSubscription.ThingPreference); - writer.WriteStartArray("valueSet"u8); - - foreach(var valueSetItem in parameterSubscription.ValueSet.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueSetItem); - } - - writer.WriteEndArray(); - - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterSubscription for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(parameterSubscription.Actor.HasValue) - { - writer.WriteStringValue(parameterSubscription.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterSubscription.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterSubscription.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterSubscription.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterSubscription.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterSubscription.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(parameterSubscription.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterSubscription.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterSubscription.ThingPreference); - writer.WriteStartArray("valueSet"u8); - - foreach(var valueSetItem in parameterSubscription.ValueSet.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueSetItem); - } - - writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -244,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -252,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -270,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -288,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -306,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -324,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -342,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -360,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -378,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -396,7 +265,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -414,7 +289,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "valueset": - if(!AllowedVersionsPerProperty["valueSet"].Contains(requestedVersion)) + var allowedVersionsForValueSet = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueSet.Contains(requestedVersion)) { return; } @@ -437,21 +320,181 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "valueSet", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not ParameterSubscription parameterSubscription) + { + throw new ArgumentException("The thing shall be a ParameterSubscription", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ParameterSubscription since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterSubscription for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterSubscription.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterSubscription.Iid); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(parameterSubscription.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterSubscription.RevisionNumber); + writer.WriteStartArray("valueSet"u8); + + foreach(var valueSetItem in parameterSubscription.ValueSet.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueSetItem); + } + + writer.WriteEndArray(); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterSubscription for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterSubscription.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterSubscription.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterSubscription.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterSubscription.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterSubscription.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(parameterSubscription.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterSubscription.RevisionNumber); + writer.WriteStartArray("valueSet"u8); + + foreach(var valueSetItem in parameterSubscription.ValueSet.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueSetItem); + } + + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterSubscription for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterSubscription.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterSubscription.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterSubscription.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterSubscription.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterSubscription.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(parameterSubscription.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterSubscription.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterSubscription.ThingPreference); + writer.WriteStartArray("valueSet"u8); + + foreach(var valueSetItem in parameterSubscription.ValueSet.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueSetItem); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterSubscription for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(parameterSubscription.Actor.HasValue) + { + writer.WriteStringValue(parameterSubscription.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterSubscription.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterSubscription.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterSubscription.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterSubscription.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterSubscription.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(parameterSubscription.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterSubscription.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterSubscription.ThingPreference); + writer.WriteStartArray("valueSet"u8); + + foreach(var valueSetItem in parameterSubscription.ValueSet.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueSetItem); + } + + writer.WriteEndArray(); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSubscriptionValueSetSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSubscriptionValueSetSerializer.cs index 41371a9c..3234ca5c 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSubscriptionValueSetSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterSubscriptionValueSetSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,169 +49,6 @@ namespace CDP4JsonSerializer /// public class ParameterSubscriptionValueSetSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ParameterSubscriptionValueSet parameterSubscriptionValueSet) - { - throw new ArgumentException("The thing shall be a ParameterSubscriptionValueSet", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ParameterSubscriptionValueSet since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterSubscriptionValueSet for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.Iid); - writer.WriteString("manual"u8, parameterSubscriptionValueSet.Manual.ToJsonString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterSubscriptionValueSet.RevisionNumber); - writer.WritePropertyName("subscribedValueSet"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.SubscribedValueSet); - writer.WritePropertyName("valueSwitch"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ValueSwitch.ToString()); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterSubscriptionValueSet for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterSubscriptionValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterSubscriptionValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.Iid); - writer.WriteString("manual"u8, parameterSubscriptionValueSet.Manual.ToJsonString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterSubscriptionValueSet.RevisionNumber); - writer.WritePropertyName("subscribedValueSet"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.SubscribedValueSet); - writer.WritePropertyName("valueSwitch"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ValueSwitch.ToString()); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterSubscriptionValueSet for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterSubscriptionValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterSubscriptionValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.Iid); - writer.WriteString("manual"u8, parameterSubscriptionValueSet.Manual.ToJsonString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterSubscriptionValueSet.RevisionNumber); - writer.WritePropertyName("subscribedValueSet"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.SubscribedValueSet); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ThingPreference); - writer.WritePropertyName("valueSwitch"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ValueSwitch.ToString()); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterSubscriptionValueSet for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(parameterSubscriptionValueSet.Actor.HasValue) - { - writer.WriteStringValue(parameterSubscriptionValueSet.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterSubscriptionValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterSubscriptionValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.Iid); - writer.WriteString("manual"u8, parameterSubscriptionValueSet.Manual.ToJsonString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterSubscriptionValueSet.RevisionNumber); - writer.WritePropertyName("subscribedValueSet"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.SubscribedValueSet); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ThingPreference); - writer.WritePropertyName("valueSwitch"u8); - writer.WriteStringValue(parameterSubscriptionValueSet.ValueSwitch.ToString()); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -220,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -228,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -246,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -264,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -282,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -300,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -318,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "manual": - if(!AllowedVersionsPerProperty["manual"].Contains(requestedVersion)) + var allowedVersionsForManual = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForManual.Contains(requestedVersion)) { return; } @@ -326,7 +204,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteString("manual"u8, ((ValueArray)value).ToJsonString()); break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -344,7 +229,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -362,7 +255,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "subscribedvalueset": - if(!AllowedVersionsPerProperty["subscribedValueSet"].Contains(requestedVersion)) + var allowedVersionsForSubscribedValueSet = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSubscribedValueSet.Contains(requestedVersion)) { return; } @@ -380,7 +281,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -398,7 +305,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "valueswitch": - if(!AllowedVersionsPerProperty["valueSwitch"].Contains(requestedVersion)) + var allowedVersionsForValueSwitch = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueSwitch.Contains(requestedVersion)) { return; } @@ -421,22 +336,161 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "manual", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "subscribedValueSet", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "valueSwitch", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not ParameterSubscriptionValueSet parameterSubscriptionValueSet) + { + throw new ArgumentException("The thing shall be a ParameterSubscriptionValueSet", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ParameterSubscriptionValueSet since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterSubscriptionValueSet for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.Iid); + writer.WriteString("manual"u8, parameterSubscriptionValueSet.Manual.ToJsonString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterSubscriptionValueSet.RevisionNumber); + writer.WritePropertyName("subscribedValueSet"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.SubscribedValueSet); + writer.WritePropertyName("valueSwitch"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ValueSwitch.ToString()); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterSubscriptionValueSet for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterSubscriptionValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterSubscriptionValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.Iid); + writer.WriteString("manual"u8, parameterSubscriptionValueSet.Manual.ToJsonString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterSubscriptionValueSet.RevisionNumber); + writer.WritePropertyName("subscribedValueSet"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.SubscribedValueSet); + writer.WritePropertyName("valueSwitch"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ValueSwitch.ToString()); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterSubscriptionValueSet for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterSubscriptionValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterSubscriptionValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.Iid); + writer.WriteString("manual"u8, parameterSubscriptionValueSet.Manual.ToJsonString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterSubscriptionValueSet.RevisionNumber); + writer.WritePropertyName("subscribedValueSet"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.SubscribedValueSet); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ThingPreference); + writer.WritePropertyName("valueSwitch"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ValueSwitch.ToString()); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterSubscriptionValueSet for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(parameterSubscriptionValueSet.Actor.HasValue) + { + writer.WriteStringValue(parameterSubscriptionValueSet.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterSubscriptionValueSet.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterSubscriptionValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.Iid); + writer.WriteString("manual"u8, parameterSubscriptionValueSet.Manual.ToJsonString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterSubscriptionValueSet.RevisionNumber); + writer.WritePropertyName("subscribedValueSet"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.SubscribedValueSet); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ThingPreference); + writer.WritePropertyName("valueSwitch"u8); + writer.WriteStringValue(parameterSubscriptionValueSet.ValueSwitch.ToString()); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterTypeComponentSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterTypeComponentSerializer.cs index 2c525353..173e8bc3 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterTypeComponentSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterTypeComponentSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,209 +49,6 @@ namespace CDP4JsonSerializer /// public class ParameterTypeComponentSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ParameterTypeComponent parameterTypeComponent) - { - throw new ArgumentException("The thing shall be a ParameterTypeComponent", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ParameterTypeComponent since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterTypeComponent for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterTypeComponent.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterTypeComponent.Iid); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(parameterTypeComponent.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterTypeComponent.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(parameterTypeComponent.Scale.HasValue) - { - writer.WriteStringValue(parameterTypeComponent.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(parameterTypeComponent.ShortName); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterTypeComponent for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterTypeComponent.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterTypeComponent.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterTypeComponent.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterTypeComponent.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterTypeComponent.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(parameterTypeComponent.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterTypeComponent.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(parameterTypeComponent.Scale.HasValue) - { - writer.WriteStringValue(parameterTypeComponent.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(parameterTypeComponent.ShortName); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterTypeComponent for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterTypeComponent.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterTypeComponent.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterTypeComponent.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterTypeComponent.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterTypeComponent.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(parameterTypeComponent.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterTypeComponent.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(parameterTypeComponent.Scale.HasValue) - { - writer.WriteStringValue(parameterTypeComponent.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(parameterTypeComponent.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterTypeComponent.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterTypeComponent for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(parameterTypeComponent.Actor.HasValue) - { - writer.WriteStringValue(parameterTypeComponent.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterTypeComponent.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterTypeComponent.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterTypeComponent.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterTypeComponent.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterTypeComponent.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(parameterTypeComponent.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterTypeComponent.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(parameterTypeComponent.Scale.HasValue) - { - writer.WriteStringValue(parameterTypeComponent.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(parameterTypeComponent.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterTypeComponent.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -260,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -268,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -286,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -304,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -322,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -340,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -358,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -376,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + var allowedVersionsForParameterType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterType.Contains(requestedVersion)) { return; } @@ -394,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -412,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "scale": - if(!AllowedVersionsPerProperty["scale"].Contains(requestedVersion)) + var allowedVersionsForScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForScale.Contains(requestedVersion)) { return; } @@ -430,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -448,7 +317,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -471,22 +346,201 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "scale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not ParameterTypeComponent parameterTypeComponent) + { + throw new ArgumentException("The thing shall be a ParameterTypeComponent", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ParameterTypeComponent since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterTypeComponent for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterTypeComponent.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterTypeComponent.Iid); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(parameterTypeComponent.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterTypeComponent.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(parameterTypeComponent.Scale.HasValue) + { + writer.WriteStringValue(parameterTypeComponent.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(parameterTypeComponent.ShortName); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterTypeComponent for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterTypeComponent.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterTypeComponent.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterTypeComponent.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterTypeComponent.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterTypeComponent.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(parameterTypeComponent.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterTypeComponent.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(parameterTypeComponent.Scale.HasValue) + { + writer.WriteStringValue(parameterTypeComponent.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(parameterTypeComponent.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterTypeComponent for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterTypeComponent.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterTypeComponent.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterTypeComponent.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterTypeComponent.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterTypeComponent.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(parameterTypeComponent.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterTypeComponent.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(parameterTypeComponent.Scale.HasValue) + { + writer.WriteStringValue(parameterTypeComponent.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(parameterTypeComponent.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterTypeComponent.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterTypeComponent for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(parameterTypeComponent.Actor.HasValue) + { + writer.WriteStringValue(parameterTypeComponent.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterTypeComponent.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterTypeComponent.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterTypeComponent.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterTypeComponent.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterTypeComponent.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(parameterTypeComponent.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterTypeComponent.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(parameterTypeComponent.Scale.HasValue) + { + writer.WriteStringValue(parameterTypeComponent.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(parameterTypeComponent.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterTypeComponent.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterValueSetSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterValueSetSerializer.cs index 56326cec..6ffcd74d 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterValueSetSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterValueSetSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,6 +49,382 @@ namespace CDP4JsonSerializer /// public class ParameterValueSetSerializer : BaseThingSerializer, IThingSerializer { + /// + /// Serialize a value for a property into a + /// + /// The name of the property to serialize + /// The object value to serialize + /// The + /// The that has been requested for the serialization + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + var requestedVersion = requestedDataModelVersion.ToString(3); + + switch(propertyName.ToLower()) + { + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "actualoption": + var allowedVersionsForActualOption = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForActualOption.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("actualOption"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "actualstate": + var allowedVersionsForActualState = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForActualState.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("actualState"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("classKind"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } + + break; + case "computed": + var allowedVersionsForComputed = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForComputed.Contains(requestedVersion)) + { + return; + } + + writer.WriteString("computed"u8, ((ValueArray)value).ToJsonString()); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + + writer.WriteEndArray(); + break; + case "formula": + var allowedVersionsForFormula = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFormula.Contains(requestedVersion)) + { + return; + } + + writer.WriteString("formula"u8, ((ValueArray)value).ToJsonString()); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "manual": + var allowedVersionsForManual = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForManual.Contains(requestedVersion)) + { + return; + } + + writer.WriteString("manual"u8, ((ValueArray)value).ToJsonString()); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "published": + var allowedVersionsForPublished = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPublished.Contains(requestedVersion)) + { + return; + } + + writer.WriteString("published"u8, ((ValueArray)value).ToJsonString()); + break; + case "reference": + var allowedVersionsForReference = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReference.Contains(requestedVersion)) + { + return; + } + + writer.WriteString("reference"u8, ((ValueArray)value).ToJsonString()); + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "valueswitch": + var allowedVersionsForValueSwitch = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueSwitch.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("valueSwitch"u8); + + if(value != null) + { + writer.WriteStringValue(((ParameterSwitchKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } + + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ParameterValueSet"); + } + } + /// /// Serializes a into an /// @@ -76,7 +451,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM switch(requestedDataModelVersion.ToString(3)) { case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterValueSet for Version 1.0.0"); + Logger.Log(LogLevel.Debug, "Serializing ParameterValueSet for Version 1.0.0"); writer.WritePropertyName("actualOption"u8); if(parameterValueSet.ActualOption.HasValue) @@ -114,7 +489,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(parameterValueSet.ValueSwitch.ToString()); break; case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterValueSet for Version 1.1.0"); + Logger.Log(LogLevel.Debug, "Serializing ParameterValueSet for Version 1.1.0"); writer.WritePropertyName("actualOption"u8); if(parameterValueSet.ActualOption.HasValue) @@ -148,7 +523,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in parameterValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -157,7 +531,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteString("formula"u8, parameterValueSet.Formula.ToJsonString()); writer.WritePropertyName("iid"u8); writer.WriteStringValue(parameterValueSet.Iid); @@ -172,7 +545,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(parameterValueSet.ValueSwitch.ToString()); break; case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterValueSet for Version 1.2.0"); + Logger.Log(LogLevel.Debug, "Serializing ParameterValueSet for Version 1.2.0"); writer.WritePropertyName("actualOption"u8); if(parameterValueSet.ActualOption.HasValue) @@ -206,7 +579,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in parameterValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -215,7 +587,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteString("formula"u8, parameterValueSet.Formula.ToJsonString()); writer.WritePropertyName("iid"u8); writer.WriteStringValue(parameterValueSet.Iid); @@ -232,7 +603,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(parameterValueSet.ValueSwitch.ToString()); break; case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterValueSet for Version 1.3.0"); + Logger.Log(LogLevel.Debug, "Serializing ParameterValueSet for Version 1.3.0"); writer.WritePropertyName("actor"u8); if(parameterValueSet.Actor.HasValue) @@ -277,7 +648,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in parameterValueSet.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -286,7 +656,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteString("formula"u8, parameterValueSet.Formula.ToJsonString()); writer.WritePropertyName("iid"u8); writer.WriteStringValue(parameterValueSet.Iid); @@ -308,286 +677,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteEndObject(); } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "actualoption": - if(!AllowedVersionsPerProperty["actualOption"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actualOption"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "actualstate": - if(!AllowedVersionsPerProperty["actualState"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actualState"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "computed": - if(!AllowedVersionsPerProperty["computed"].Contains(requestedVersion)) - { - return; - } - - writer.WriteString("computed"u8, ((ValueArray)value).ToJsonString()); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "formula": - if(!AllowedVersionsPerProperty["formula"].Contains(requestedVersion)) - { - return; - } - - writer.WriteString("formula"u8, ((ValueArray)value).ToJsonString()); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "manual": - if(!AllowedVersionsPerProperty["manual"].Contains(requestedVersion)) - { - return; - } - - writer.WriteString("manual"u8, ((ValueArray)value).ToJsonString()); - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "published": - if(!AllowedVersionsPerProperty["published"].Contains(requestedVersion)) - { - return; - } - - writer.WriteString("published"u8, ((ValueArray)value).ToJsonString()); - break; - case "reference": - if(!AllowedVersionsPerProperty["reference"].Contains(requestedVersion)) - { - return; - } - - writer.WriteString("reference"u8, ((ValueArray)value).ToJsonString()); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "valueswitch": - if(!AllowedVersionsPerProperty["valueSwitch"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("valueSwitch"u8); - - if(value != null) - { - writer.WriteStringValue(((ParameterSwitchKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ParameterValueSet"); - } - } - - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "actualOption", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "actualState", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "computed", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "formula", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "manual", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "published", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "reference", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "valueSwitch", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterizedCategoryRuleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterizedCategoryRuleSerializer.cs index a55f0d55..b300a61d 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterizedCategoryRuleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParameterizedCategoryRuleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,349 +50,317 @@ namespace CDP4JsonSerializer public class ParameterizedCategoryRuleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ParameterizedCategoryRule parameterizedCategoryRule) - { - throw new ArgumentException("The thing shall be a ParameterizedCategoryRule", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ParameterizedCategoryRule since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterizedCategoryRule for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in parameterizedCategoryRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("category"u8); - writer.WriteStringValue(parameterizedCategoryRule.Category); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterizedCategoryRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in parameterizedCategoryRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in parameterizedCategoryRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterizedCategoryRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(parameterizedCategoryRule.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(parameterizedCategoryRule.Name); - writer.WriteStartArray("parameterType"u8); + writer.WriteStartArray("alias"u8); - foreach(var parameterTypeItem in parameterizedCategoryRule.ParameterType.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(parameterTypeItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterizedCategoryRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(parameterizedCategoryRule.ShortName); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterizedCategoryRule for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in parameterizedCategoryRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("category"u8); - writer.WriteStringValue(parameterizedCategoryRule.Category); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterizedCategoryRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in parameterizedCategoryRule.Definition.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in parameterizedCategoryRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in parameterizedCategoryRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in parameterizedCategoryRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterizedCategoryRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(parameterizedCategoryRule.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterizedCategoryRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(parameterizedCategoryRule.Name); - writer.WriteStartArray("parameterType"u8); + writer.WriteStartArray("definition"u8); - foreach(var parameterTypeItem in parameterizedCategoryRule.ParameterType.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(parameterTypeItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterizedCategoryRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(parameterizedCategoryRule.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterizedCategoryRule for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in parameterizedCategoryRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("category"u8); - writer.WriteStringValue(parameterizedCategoryRule.Category); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterizedCategoryRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in parameterizedCategoryRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in parameterizedCategoryRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in parameterizedCategoryRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in parameterizedCategoryRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterizedCategoryRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(parameterizedCategoryRule.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterizedCategoryRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(parameterizedCategoryRule.Name); - writer.WriteStartArray("parameterType"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var parameterTypeItem in parameterizedCategoryRule.ParameterType.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(parameterTypeItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterizedCategoryRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(parameterizedCategoryRule.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterizedCategoryRule.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ParameterizedCategoryRule for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(parameterizedCategoryRule.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(parameterizedCategoryRule.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in parameterizedCategoryRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WritePropertyName("category"u8); - writer.WriteStringValue(parameterizedCategoryRule.Category); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(parameterizedCategoryRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in parameterizedCategoryRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in parameterizedCategoryRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in parameterizedCategoryRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in parameterizedCategoryRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(parameterizedCategoryRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(parameterizedCategoryRule.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(parameterizedCategoryRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(parameterizedCategoryRule.Name); - writer.WriteStartArray("parameterType"u8); - - foreach(var parameterTypeItem in parameterizedCategoryRule.ParameterType.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(parameterTypeItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(parameterizedCategoryRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(parameterizedCategoryRule.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(parameterizedCategoryRule.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -401,35 +368,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "parametertype": + var allowedVersionsForParameterType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterType.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("parameterType"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListParameterType) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var parameterTypeItem in objectListParameterType.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteStringValue(parameterTypeItem); } } writer.WriteEndArray(); break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("category"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -437,17 +420,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -455,249 +446,331 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedDomain"u8); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ParameterizedCategoryRule"); + } + } - if(value is IEnumerable objectListExcludedDomain) + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ParameterizedCategoryRule parameterizedCategoryRule) + { + throw new ArgumentException("The thing shall be a ParameterizedCategoryRule", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ParameterizedCategoryRule since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterizedCategoryRule for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in parameterizedCategoryRule.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WritePropertyName("category"u8); + writer.WriteStringValue(parameterizedCategoryRule.Category); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterizedCategoryRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in parameterizedCategoryRule.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var hyperLinkItem in parameterizedCategoryRule.HyperLink.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(hyperLinkItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterizedCategoryRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(parameterizedCategoryRule.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(parameterizedCategoryRule.Name); + writer.WriteStartArray("parameterType"u8); + + foreach(var parameterTypeItem in parameterizedCategoryRule.ParameterType.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(parameterTypeItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterizedCategoryRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(parameterizedCategoryRule.ShortName); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterizedCategoryRule for Version 1.1.0"); + writer.WriteStartArray("alias"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var aliasItem in parameterizedCategoryRule.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WritePropertyName("category"u8); + writer.WriteStringValue(parameterizedCategoryRule.Category); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterizedCategoryRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in parameterizedCategoryRule.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterizedCategoryRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterizedCategoryRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in parameterizedCategoryRule.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterizedCategoryRule.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else + writer.WriteBooleanValue(parameterizedCategoryRule.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterizedCategoryRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(parameterizedCategoryRule.Name); + writer.WriteStartArray("parameterType"u8); + + foreach(var parameterTypeItem in parameterizedCategoryRule.ParameterType.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(parameterTypeItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterizedCategoryRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(parameterizedCategoryRule.ShortName); break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterizedCategoryRule for Version 1.2.0"); + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else + foreach(var aliasItem in parameterizedCategoryRule.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(aliasItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("category"u8); + writer.WriteStringValue(parameterizedCategoryRule.Category); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterizedCategoryRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in parameterizedCategoryRule.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterizedCategoryRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterizedCategoryRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in parameterizedCategoryRule.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterizedCategoryRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(parameterizedCategoryRule.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterizedCategoryRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(parameterizedCategoryRule.Name); writer.WriteStartArray("parameterType"u8); - if(value is IEnumerable objectListParameterType) + foreach(var parameterTypeItem in parameterizedCategoryRule.ParameterType.OrderBy(x => x, this.GuidComparer)) { - foreach(var parameterTypeItem in objectListParameterType.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterTypeItem); - } + writer.WriteStringValue(parameterTypeItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterizedCategoryRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(parameterizedCategoryRule.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterizedCategoryRule.ThingPreference); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ParameterizedCategoryRule for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(parameterizedCategoryRule.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(parameterizedCategoryRule.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in parameterizedCategoryRule.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("category"u8); + writer.WriteStringValue(parameterizedCategoryRule.Category); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(parameterizedCategoryRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in parameterizedCategoryRule.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in parameterizedCategoryRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in parameterizedCategoryRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in parameterizedCategoryRule.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(parameterizedCategoryRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(parameterizedCategoryRule.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(parameterizedCategoryRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(parameterizedCategoryRule.Name); + writer.WriteStartArray("parameterType"u8); + + foreach(var parameterTypeItem in parameterizedCategoryRule.ParameterType.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(parameterTypeItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(parameterizedCategoryRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(parameterizedCategoryRule.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(parameterizedCategoryRule.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ParameterizedCategoryRule"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParametricConstraintSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParametricConstraintSerializer.cs index 225ac2c7..767379e4 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParametricConstraintSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParametricConstraintSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,6 +49,276 @@ namespace CDP4JsonSerializer /// public class ParametricConstraintSerializer : BaseThingSerializer, IThingSerializer { + /// + /// Serialize a value for a property into a + /// + /// The name of the property to serialize + /// The object value to serialize + /// The + /// The that has been requested for the serialization + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + var requestedVersion = requestedDataModelVersion.ToString(3); + + switch(propertyName.ToLower()) + { + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("classKind"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } + + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + + writer.WriteEndArray(); + break; + case "expression": + var allowedVersionsForExpression = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExpression.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("expression"u8); + + if(value is IEnumerable objectListExpression) + { + foreach(var expressionItem in objectListExpression.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(expressionItem); + } + } + + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "topexpression": + var allowedVersionsForTopExpression = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTopExpression.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("topExpression"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ParametricConstraint"); + } + } + /// /// Serializes a into an /// @@ -76,7 +345,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM switch(requestedDataModelVersion.ToString(3)) { case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ParametricConstraint for Version 1.0.0"); + Logger.Log(LogLevel.Debug, "Serializing ParametricConstraint for Version 1.0.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(parametricConstraint.ClassKind.ToString()); writer.WriteStartArray("expression"u8); @@ -87,7 +356,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(parametricConstraint.Iid); writer.WritePropertyName("revisionNumber"u8); @@ -105,7 +373,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM break; case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ParametricConstraint for Version 1.1.0"); + Logger.Log(LogLevel.Debug, "Serializing ParametricConstraint for Version 1.1.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(parametricConstraint.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -116,7 +384,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in parametricConstraint.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -125,7 +392,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("expression"u8); foreach(var expressionItem in parametricConstraint.Expression.OrderBy(x => x, this.GuidComparer)) @@ -134,7 +400,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(parametricConstraint.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -154,7 +419,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM break; case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ParametricConstraint for Version 1.2.0"); + Logger.Log(LogLevel.Debug, "Serializing ParametricConstraint for Version 1.2.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(parametricConstraint.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -165,7 +430,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in parametricConstraint.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -174,7 +438,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("expression"u8); foreach(var expressionItem in parametricConstraint.Expression.OrderBy(x => x, this.GuidComparer)) @@ -183,7 +446,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(parametricConstraint.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -205,7 +467,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM break; case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ParametricConstraint for Version 1.3.0"); + Logger.Log(LogLevel.Debug, "Serializing ParametricConstraint for Version 1.3.0"); writer.WritePropertyName("actor"u8); if(parametricConstraint.Actor.HasValue) @@ -227,7 +489,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in parametricConstraint.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -236,7 +497,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("expression"u8); foreach(var expressionItem in parametricConstraint.Expression.OrderBy(x => x, this.GuidComparer)) @@ -245,7 +505,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(parametricConstraint.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -272,222 +531,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteEndObject(); } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "expression": - if(!AllowedVersionsPerProperty["expression"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("expression"u8); - - if(value is IEnumerable objectListExpression) - { - foreach(var expressionItem in objectListExpression.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(expressionItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "topexpression": - if(!AllowedVersionsPerProperty["topExpression"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("topExpression"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ParametricConstraint"); - } - } - - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "expression", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "topExpression", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantPermissionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantPermissionSerializer.cs index 1f5e997d..d3241fb9 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantPermissionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantPermissionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,173 +49,6 @@ namespace CDP4JsonSerializer /// public class ParticipantPermissionSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ParticipantPermission participantPermission) - { - throw new ArgumentException("The thing shall be a ParticipantPermission", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ParticipantPermission since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ParticipantPermission for Version 1.0.0"); - writer.WritePropertyName("accessRight"u8); - writer.WriteStringValue(participantPermission.AccessRight.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participantPermission.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participantPermission.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(participantPermission.IsDeprecated); - writer.WritePropertyName("objectClass"u8); - writer.WriteStringValue(participantPermission.ObjectClass.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participantPermission.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ParticipantPermission for Version 1.1.0"); - writer.WritePropertyName("accessRight"u8); - writer.WriteStringValue(participantPermission.AccessRight.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participantPermission.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in participantPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in participantPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participantPermission.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(participantPermission.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(participantPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("objectClass"u8); - writer.WriteStringValue(participantPermission.ObjectClass.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participantPermission.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ParticipantPermission for Version 1.2.0"); - writer.WritePropertyName("accessRight"u8); - writer.WriteStringValue(participantPermission.AccessRight.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participantPermission.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in participantPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in participantPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participantPermission.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(participantPermission.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(participantPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("objectClass"u8); - writer.WriteStringValue(participantPermission.ObjectClass.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participantPermission.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(participantPermission.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ParticipantPermission for Version 1.3.0"); - writer.WritePropertyName("accessRight"u8); - writer.WriteStringValue(participantPermission.AccessRight.ToString()); - writer.WritePropertyName("actor"u8); - - if(participantPermission.Actor.HasValue) - { - writer.WriteStringValue(participantPermission.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participantPermission.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in participantPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in participantPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participantPermission.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(participantPermission.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(participantPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("objectClass"u8); - writer.WriteStringValue(participantPermission.ObjectClass.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participantPermission.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(participantPermission.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -224,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -232,7 +63,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "accessright": - if(!AllowedVersionsPerProperty["accessRight"].Contains(requestedVersion)) + var allowedVersionsForAccessRight = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAccessRight.Contains(requestedVersion)) { return; } @@ -250,7 +89,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -268,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -286,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -304,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -322,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -340,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { return; } @@ -358,7 +240,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -376,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "objectclass": - if(!AllowedVersionsPerProperty["objectClass"].Contains(requestedVersion)) + var allowedVersionsForObjectClass = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForObjectClass.Contains(requestedVersion)) { return; } @@ -394,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -412,7 +317,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -435,22 +346,165 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "accessRight", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "objectClass", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not ParticipantPermission participantPermission) + { + throw new ArgumentException("The thing shall be a ParticipantPermission", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ParticipantPermission since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ParticipantPermission for Version 1.0.0"); + writer.WritePropertyName("accessRight"u8); + writer.WriteStringValue(participantPermission.AccessRight.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participantPermission.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(participantPermission.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(participantPermission.IsDeprecated); + writer.WritePropertyName("objectClass"u8); + writer.WriteStringValue(participantPermission.ObjectClass.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(participantPermission.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ParticipantPermission for Version 1.1.0"); + writer.WritePropertyName("accessRight"u8); + writer.WriteStringValue(participantPermission.AccessRight.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participantPermission.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in participantPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in participantPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(participantPermission.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(participantPermission.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(participantPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("objectClass"u8); + writer.WriteStringValue(participantPermission.ObjectClass.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(participantPermission.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ParticipantPermission for Version 1.2.0"); + writer.WritePropertyName("accessRight"u8); + writer.WriteStringValue(participantPermission.AccessRight.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participantPermission.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in participantPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in participantPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(participantPermission.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(participantPermission.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(participantPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("objectClass"u8); + writer.WriteStringValue(participantPermission.ObjectClass.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(participantPermission.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(participantPermission.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ParticipantPermission for Version 1.3.0"); + writer.WritePropertyName("accessRight"u8); + writer.WriteStringValue(participantPermission.AccessRight.ToString()); + writer.WritePropertyName("actor"u8); + + if(participantPermission.Actor.HasValue) + { + writer.WriteStringValue(participantPermission.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participantPermission.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in participantPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in participantPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(participantPermission.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(participantPermission.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(participantPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("objectClass"u8); + writer.WriteStringValue(participantPermission.ObjectClass.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(participantPermission.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(participantPermission.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantRoleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantRoleSerializer.cs index 6e9fdced..8d97e9a7 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantRoleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantRoleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,341 +50,291 @@ namespace CDP4JsonSerializer public class ParticipantRoleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ParticipantRole participantRole) - { - throw new ArgumentException("The thing shall be a ParticipantRole", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ParticipantRole since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ParticipantRole for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in participantRole.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participantRole.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in participantRole.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in participantRole.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participantRole.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(participantRole.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(participantRole.Name); - writer.WriteStartArray("participantPermission"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var participantPermissionItem in participantRole.ParticipantPermission.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(participantPermissionItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participantRole.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(participantRole.ShortName); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ParticipantRole for Version 1.1.0"); writer.WriteStartArray("alias"u8); - foreach(var aliasItem in participantRole.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(aliasItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participantRole.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in participantRole.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in participantRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in participantRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in participantRole.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participantRole.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(participantRole.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(participantRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(participantRole.Name); - writer.WriteStartArray("participantPermission"u8); + writer.WriteStartArray("definition"u8); - foreach(var participantPermissionItem in participantRole.ParticipantPermission.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(participantPermissionItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participantRole.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(participantRole.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ParticipantRole for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in participantRole.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participantRole.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in participantRole.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in participantRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in participantRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in participantRole.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participantRole.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(participantRole.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(participantRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(participantRole.Name); - writer.WriteStartArray("participantPermission"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var participantPermissionItem in participantRole.ParticipantPermission.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(participantPermissionItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participantRole.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(participantRole.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(participantRole.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ParticipantRole for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(participantRole.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(participantRole.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in participantRole.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participantRole.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in participantRole.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in participantRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List { - writer.WriteStringValue(excludedDomainItem); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in participantRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in participantRole.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participantRole.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(participantRole.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(participantRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(participantRole.Name); - writer.WriteStartArray("participantPermission"u8); - - foreach(var participantPermissionItem in participantRole.ParticipantPermission.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(participantPermissionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participantRole.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(participantRole.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(participantRole.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -393,35 +342,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "participantpermission": + var allowedVersionsForParticipantPermission = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParticipantPermission.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("participantPermission"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListParticipantPermission) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var participantPermissionItem in objectListParticipantPermission.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteStringValue(participantPermissionItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -429,248 +394,349 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + writer.WritePropertyName("shortName"u8); + + if(value != null) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedDomain"u8); + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListExcludedDomain) + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + return; } + + writer.WritePropertyName("thingPreference"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ParticipantRole"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ParticipantRole participantRole) + { + throw new ArgumentException("The thing shall be a ParticipantRole", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ParticipantRole since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ParticipantRole for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in participantRole.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participantRole.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var definitionItem in participantRole.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in participantRole.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + writer.WriteStringValue(participantRole.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(participantRole.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(participantRole.Name); + writer.WriteStartArray("participantPermission"u8); + + foreach(var participantPermissionItem in participantRole.ParticipantPermission.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(participantPermissionItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(participantRole.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(participantRole.ShortName); break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ParticipantRole for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in participantRole.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participantRole.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in participantRole.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in participantRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in participantRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in participantRole.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(participantRole.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(participantRole.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(participantRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(participantRole.Name); + writer.WriteStartArray("participantPermission"u8); + + foreach(var participantPermissionItem in participantRole.ParticipantPermission.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(participantPermissionItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(participantRole.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(participantRole.ShortName); break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ParticipantRole for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in participantRole.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participantRole.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in participantRole.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in participantRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "participantpermission": - if(!AllowedVersionsPerProperty["participantPermission"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in participantRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WriteStartArray("participantPermission"u8); + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListParticipantPermission) + foreach(var hyperLinkItem in participantRole.HyperLink.OrderBy(x => x, this.GuidComparer)) { - foreach(var participantPermissionItem in objectListParticipantPermission.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(participantPermissionItem); - } + writer.WriteStringValue(hyperLinkItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(participantRole.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(participantRole.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(participantRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(participantRole.Name); + writer.WriteStartArray("participantPermission"u8); + + foreach(var participantPermissionItem in participantRole.ParticipantPermission.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(participantPermissionItem); } + writer.WriteEndArray(); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(participantRole.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(participantRole.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(participantRole.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ParticipantRole for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(participantRole.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(participantRole.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in participantRole.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participantRole.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in participantRole.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in participantRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in participantRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in participantRole.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(participantRole.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(participantRole.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(participantRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(participantRole.Name); + writer.WriteStartArray("participantPermission"u8); + + foreach(var participantPermissionItem in participantRole.ParticipantPermission.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(participantPermissionItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(participantRole.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(participantRole.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(participantRole.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ParticipantRole"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "participantPermission", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantSerializer.cs index 1f162cfc..e178a731 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ParticipantSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,217 +49,6 @@ namespace CDP4JsonSerializer /// public class ParticipantSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Participant participant) - { - throw new ArgumentException("The thing shall be a Participant", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Participant since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Participant for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participant.ClassKind.ToString()); - writer.WriteStartArray("domain"u8); - - foreach(var domainItem in participant.Domain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participant.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(participant.IsActive); - writer.WritePropertyName("person"u8); - writer.WriteStringValue(participant.Person); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participant.RevisionNumber); - writer.WritePropertyName("role"u8); - writer.WriteStringValue(participant.Role); - writer.WritePropertyName("selectedDomain"u8); - writer.WriteStringValue(participant.SelectedDomain); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Participant for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participant.ClassKind.ToString()); - writer.WriteStartArray("domain"u8); - - foreach(var domainItem in participant.Domain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in participant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in participant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participant.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(participant.IsActive); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(participant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("person"u8); - writer.WriteStringValue(participant.Person); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participant.RevisionNumber); - writer.WritePropertyName("role"u8); - writer.WriteStringValue(participant.Role); - writer.WritePropertyName("selectedDomain"u8); - writer.WriteStringValue(participant.SelectedDomain); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Participant for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participant.ClassKind.ToString()); - writer.WriteStartArray("domain"u8); - - foreach(var domainItem in participant.Domain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in participant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in participant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participant.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(participant.IsActive); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(participant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("person"u8); - writer.WriteStringValue(participant.Person); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participant.RevisionNumber); - writer.WritePropertyName("role"u8); - writer.WriteStringValue(participant.Role); - writer.WritePropertyName("selectedDomain"u8); - writer.WriteStringValue(participant.SelectedDomain); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(participant.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Participant for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(participant.Actor.HasValue) - { - writer.WriteStringValue(participant.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(participant.ClassKind.ToString()); - writer.WriteStartArray("domain"u8); - - foreach(var domainItem in participant.Domain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in participant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in participant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(participant.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(participant.IsActive); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(participant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("person"u8); - writer.WriteStringValue(participant.Person); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(participant.RevisionNumber); - writer.WritePropertyName("role"u8); - writer.WriteStringValue(participant.Role); - writer.WritePropertyName("selectedDomain"u8); - writer.WriteStringValue(participant.SelectedDomain); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(participant.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -268,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -276,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -294,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -312,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "domain": - if(!AllowedVersionsPerProperty["domain"].Contains(requestedVersion)) + var allowedVersionsForDomain = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDomain.Contains(requestedVersion)) { return; } @@ -330,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -348,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -366,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -384,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "isactive": - if(!AllowedVersionsPerProperty["isActive"].Contains(requestedVersion)) + var allowedVersionsForIsActive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsActive.Contains(requestedVersion)) { return; } @@ -402,7 +240,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -420,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "person": - if(!AllowedVersionsPerProperty["person"].Contains(requestedVersion)) + var allowedVersionsForPerson = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPerson.Contains(requestedVersion)) { return; } @@ -438,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -456,7 +317,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "role": - if(!AllowedVersionsPerProperty["role"].Contains(requestedVersion)) + var allowedVersionsForRole = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRole.Contains(requestedVersion)) { return; } @@ -474,7 +343,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "selecteddomain": - if(!AllowedVersionsPerProperty["selectedDomain"].Contains(requestedVersion)) + var allowedVersionsForSelectedDomain = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSelectedDomain.Contains(requestedVersion)) { return; } @@ -492,7 +369,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -515,24 +398,205 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "domain", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isActive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "person", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "role", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "selectedDomain", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Participant participant) + { + throw new ArgumentException("The thing shall be a Participant", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Participant since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Participant for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participant.ClassKind.ToString()); + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in participant.Domain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(participant.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(participant.IsActive); + writer.WritePropertyName("person"u8); + writer.WriteStringValue(participant.Person); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(participant.RevisionNumber); + writer.WritePropertyName("role"u8); + writer.WriteStringValue(participant.Role); + writer.WritePropertyName("selectedDomain"u8); + writer.WriteStringValue(participant.SelectedDomain); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Participant for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participant.ClassKind.ToString()); + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in participant.Domain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in participant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in participant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(participant.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(participant.IsActive); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(participant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("person"u8); + writer.WriteStringValue(participant.Person); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(participant.RevisionNumber); + writer.WritePropertyName("role"u8); + writer.WriteStringValue(participant.Role); + writer.WritePropertyName("selectedDomain"u8); + writer.WriteStringValue(participant.SelectedDomain); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Participant for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participant.ClassKind.ToString()); + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in participant.Domain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in participant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in participant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(participant.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(participant.IsActive); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(participant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("person"u8); + writer.WriteStringValue(participant.Person); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(participant.RevisionNumber); + writer.WritePropertyName("role"u8); + writer.WriteStringValue(participant.Role); + writer.WritePropertyName("selectedDomain"u8); + writer.WriteStringValue(participant.SelectedDomain); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(participant.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Participant for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(participant.Actor.HasValue) + { + writer.WriteStringValue(participant.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(participant.ClassKind.ToString()); + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in participant.Domain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in participant.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in participant.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(participant.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(participant.IsActive); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(participant.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("person"u8); + writer.WriteStringValue(participant.Person); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(participant.RevisionNumber); + writer.WritePropertyName("role"u8); + writer.WriteStringValue(participant.Role); + writer.WritePropertyName("selectedDomain"u8); + writer.WriteStringValue(participant.SelectedDomain); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(participant.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/PersonPermissionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/PersonPermissionSerializer.cs index a9ffb3fa..d253e3ac 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/PersonPermissionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/PersonPermissionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,173 +49,6 @@ namespace CDP4JsonSerializer /// public class PersonPermissionSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not PersonPermission personPermission) - { - throw new ArgumentException("The thing shall be a PersonPermission", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of PersonPermission since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing PersonPermission for Version 1.0.0"); - writer.WritePropertyName("accessRight"u8); - writer.WriteStringValue(personPermission.AccessRight.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(personPermission.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(personPermission.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(personPermission.IsDeprecated); - writer.WritePropertyName("objectClass"u8); - writer.WriteStringValue(personPermission.ObjectClass.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(personPermission.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing PersonPermission for Version 1.1.0"); - writer.WritePropertyName("accessRight"u8); - writer.WriteStringValue(personPermission.AccessRight.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(personPermission.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in personPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in personPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(personPermission.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(personPermission.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(personPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("objectClass"u8); - writer.WriteStringValue(personPermission.ObjectClass.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(personPermission.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing PersonPermission for Version 1.2.0"); - writer.WritePropertyName("accessRight"u8); - writer.WriteStringValue(personPermission.AccessRight.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(personPermission.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in personPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in personPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(personPermission.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(personPermission.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(personPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("objectClass"u8); - writer.WriteStringValue(personPermission.ObjectClass.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(personPermission.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(personPermission.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing PersonPermission for Version 1.3.0"); - writer.WritePropertyName("accessRight"u8); - writer.WriteStringValue(personPermission.AccessRight.ToString()); - writer.WritePropertyName("actor"u8); - - if(personPermission.Actor.HasValue) - { - writer.WriteStringValue(personPermission.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(personPermission.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in personPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in personPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(personPermission.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(personPermission.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(personPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("objectClass"u8); - writer.WriteStringValue(personPermission.ObjectClass.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(personPermission.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(personPermission.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -224,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -232,7 +63,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "accessright": - if(!AllowedVersionsPerProperty["accessRight"].Contains(requestedVersion)) + var allowedVersionsForAccessRight = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAccessRight.Contains(requestedVersion)) { return; } @@ -250,7 +89,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -268,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -286,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -304,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -322,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -340,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { return; } @@ -358,7 +240,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -376,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "objectclass": - if(!AllowedVersionsPerProperty["objectClass"].Contains(requestedVersion)) + var allowedVersionsForObjectClass = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForObjectClass.Contains(requestedVersion)) { return; } @@ -394,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -412,7 +317,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -435,22 +346,165 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "accessRight", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "objectClass", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not PersonPermission personPermission) + { + throw new ArgumentException("The thing shall be a PersonPermission", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of PersonPermission since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing PersonPermission for Version 1.0.0"); + writer.WritePropertyName("accessRight"u8); + writer.WriteStringValue(personPermission.AccessRight.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(personPermission.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(personPermission.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(personPermission.IsDeprecated); + writer.WritePropertyName("objectClass"u8); + writer.WriteStringValue(personPermission.ObjectClass.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(personPermission.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing PersonPermission for Version 1.1.0"); + writer.WritePropertyName("accessRight"u8); + writer.WriteStringValue(personPermission.AccessRight.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(personPermission.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in personPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in personPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(personPermission.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(personPermission.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(personPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("objectClass"u8); + writer.WriteStringValue(personPermission.ObjectClass.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(personPermission.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing PersonPermission for Version 1.2.0"); + writer.WritePropertyName("accessRight"u8); + writer.WriteStringValue(personPermission.AccessRight.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(personPermission.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in personPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in personPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(personPermission.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(personPermission.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(personPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("objectClass"u8); + writer.WriteStringValue(personPermission.ObjectClass.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(personPermission.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(personPermission.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing PersonPermission for Version 1.3.0"); + writer.WritePropertyName("accessRight"u8); + writer.WriteStringValue(personPermission.AccessRight.ToString()); + writer.WritePropertyName("actor"u8); + + if(personPermission.Actor.HasValue) + { + writer.WriteStringValue(personPermission.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(personPermission.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in personPermission.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in personPermission.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(personPermission.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(personPermission.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(personPermission.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("objectClass"u8); + writer.WriteStringValue(personPermission.ObjectClass.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(personPermission.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(personPermission.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/PersonRoleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/PersonRoleSerializer.cs index 780e0d50..6fecd76e 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/PersonRoleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/PersonRoleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,341 +50,291 @@ namespace CDP4JsonSerializer public class PersonRoleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not PersonRole personRole) - { - throw new ArgumentException("The thing shall be a PersonRole", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of PersonRole since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing PersonRole for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in personRole.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(personRole.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in personRole.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in personRole.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(personRole.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(personRole.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(personRole.Name); - writer.WriteStartArray("personPermission"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var personPermissionItem in personRole.PersonPermission.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(personPermissionItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(personRole.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(personRole.ShortName); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing PersonRole for Version 1.1.0"); writer.WriteStartArray("alias"u8); - foreach(var aliasItem in personRole.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(aliasItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(personRole.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in personRole.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in personRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in personRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in personRole.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(personRole.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(personRole.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(personRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(personRole.Name); - writer.WriteStartArray("personPermission"u8); + writer.WriteStartArray("definition"u8); - foreach(var personPermissionItem in personRole.PersonPermission.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(personPermissionItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(personRole.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(personRole.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing PersonRole for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in personRole.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(personRole.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in personRole.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in personRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in personRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in personRole.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(personRole.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(personRole.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(personRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(personRole.Name); - writer.WriteStartArray("personPermission"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var personPermissionItem in personRole.PersonPermission.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(personPermissionItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(personRole.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(personRole.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(personRole.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing PersonRole for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(personRole.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(personRole.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in personRole.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(personRole.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in personRole.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in personRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List { - writer.WriteStringValue(excludedDomainItem); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in personRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in personRole.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(personRole.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(personRole.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(personRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(personRole.Name); - writer.WriteStartArray("personPermission"u8); - - foreach(var personPermissionItem in personRole.PersonPermission.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(personPermissionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(personRole.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(personRole.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(personRole.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -393,35 +342,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "personpermission": + var allowedVersionsForPersonPermission = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPersonPermission.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("personPermission"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListPersonPermission) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var personPermissionItem in objectListPersonPermission.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteStringValue(personPermissionItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -429,248 +394,349 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + writer.WritePropertyName("shortName"u8); + + if(value != null) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedDomain"u8); + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListExcludedDomain) + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + return; } + + writer.WritePropertyName("thingPreference"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the PersonRole"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not PersonRole personRole) + { + throw new ArgumentException("The thing shall be a PersonRole", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of PersonRole since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing PersonRole for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in personRole.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(personRole.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var definitionItem in personRole.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in personRole.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + writer.WriteStringValue(personRole.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(personRole.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(personRole.Name); + writer.WriteStartArray("personPermission"u8); + + foreach(var personPermissionItem in personRole.PersonPermission.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(personPermissionItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(personRole.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(personRole.ShortName); break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing PersonRole for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in personRole.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(personRole.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in personRole.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in personRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in personRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in personRole.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(personRole.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(personRole.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(personRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(personRole.Name); + writer.WriteStartArray("personPermission"u8); + + foreach(var personPermissionItem in personRole.PersonPermission.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(personPermissionItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(personRole.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(personRole.ShortName); break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing PersonRole for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in personRole.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(personRole.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in personRole.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in personRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "personpermission": - if(!AllowedVersionsPerProperty["personPermission"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in personRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WriteStartArray("personPermission"u8); + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListPersonPermission) + foreach(var hyperLinkItem in personRole.HyperLink.OrderBy(x => x, this.GuidComparer)) { - foreach(var personPermissionItem in objectListPersonPermission.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(personPermissionItem); - } + writer.WriteStringValue(hyperLinkItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(personRole.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(personRole.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(personRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(personRole.Name); + writer.WriteStartArray("personPermission"u8); + + foreach(var personPermissionItem in personRole.PersonPermission.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(personPermissionItem); } + writer.WriteEndArray(); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(personRole.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(personRole.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(personRole.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing PersonRole for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(personRole.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(personRole.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in personRole.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(personRole.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in personRole.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in personRole.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in personRole.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in personRole.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(personRole.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(personRole.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(personRole.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(personRole.Name); + writer.WriteStartArray("personPermission"u8); + + foreach(var personPermissionItem in personRole.PersonPermission.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(personPermissionItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(personRole.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(personRole.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(personRole.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the PersonRole"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "personPermission", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/PersonSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/PersonSerializer.cs index 5c680213..632571c7 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/PersonSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/PersonSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,262 +50,640 @@ namespace CDP4JsonSerializer public class PersonSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not Person person) - { - throw new ArgumentException("The thing shall be a Person", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.0.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of Person since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Person for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(person.ClassKind.ToString()); - writer.WritePropertyName("defaultDomain"u8); + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } - if(person.DefaultDomain.HasValue) + writer.WritePropertyName("actor"u8); + + if(value != null) { - writer.WriteStringValue(person.DefaultDomain.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("defaultEmailAddress"u8); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(person.DefaultEmailAddress.HasValue) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(person.DefaultEmailAddress.Value); + return; + } + + writer.WritePropertyName("classKind"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WritePropertyName("defaultTelephoneNumber"u8); + break; + case "defaultdomain": + var allowedVersionsForDefaultDomain = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(person.DefaultTelephoneNumber.HasValue) + if(!allowedVersionsForDefaultDomain.Contains(requestedVersion)) { - writer.WriteStringValue(person.DefaultTelephoneNumber.Value); + return; + } + + writer.WritePropertyName("defaultDomain"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("emailAddress"u8); + break; + case "defaultemailaddress": + var allowedVersionsForDefaultEmailAddress = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var emailAddressItem in person.EmailAddress.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefaultEmailAddress.Contains(requestedVersion)) { - writer.WriteStringValue(emailAddressItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("defaultEmailAddress"u8); - writer.WritePropertyName("givenName"u8); - writer.WriteStringValue(person.GivenName); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(person.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(person.IsActive); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(person.IsDeprecated); - writer.WritePropertyName("organization"u8); - - if(person.Organization.HasValue) + if(value != null) { - writer.WriteStringValue(person.Organization.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("organizationalUnit"u8); - writer.WriteStringValue(person.OrganizationalUnit); - writer.WritePropertyName("password"u8); - writer.WriteStringValue(person.Password); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(person.RevisionNumber); - writer.WritePropertyName("role"u8); + break; + case "defaulttelephonenumber": + var allowedVersionsForDefaultTelephoneNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(person.Role.HasValue) + if(!allowedVersionsForDefaultTelephoneNumber.Contains(requestedVersion)) { - writer.WriteStringValue(person.Role.Value); + return; + } + + writer.WritePropertyName("defaultTelephoneNumber"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(person.ShortName); - writer.WritePropertyName("surname"u8); - writer.WriteStringValue(person.Surname); - writer.WriteStartArray("telephoneNumber"u8); + break; + case "emailaddress": + var allowedVersionsForEmailAddress = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var telephoneNumberItem in person.TelephoneNumber.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForEmailAddress.Contains(requestedVersion)) { - writer.WriteStringValue(telephoneNumberItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("emailAddress"u8); + + if(value is IEnumerable objectListEmailAddress) + { + foreach(var emailAddressItem in objectListEmailAddress.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(emailAddressItem); + } + } - writer.WriteStartArray("userPreference"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var userPreferenceItem in person.UserPreference.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(userPreferenceItem); + return; } + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Person for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(person.ClassKind.ToString()); - writer.WritePropertyName("defaultDomain"u8); + case "givenname": + var allowedVersionsForGivenName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(person.DefaultDomain.HasValue) + if(!allowedVersionsForGivenName.Contains(requestedVersion)) { - writer.WriteStringValue(person.DefaultDomain.Value); + return; + } + + writer.WritePropertyName("givenName"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("defaultEmailAddress"u8); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(person.DefaultEmailAddress.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(person.DefaultEmailAddress.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("defaultTelephoneNumber"u8); + break; + case "isactive": + var allowedVersionsForIsActive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(person.DefaultTelephoneNumber.HasValue) + if(!allowedVersionsForIsActive.Contains(requestedVersion)) { - writer.WriteStringValue(person.DefaultTelephoneNumber.Value); + return; + } + + writer.WritePropertyName("isActive"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("emailAddress"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var emailAddressItem in person.EmailAddress.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(emailAddressItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("excludedDomain"u8); + if(value != null) + { + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedDomainItem in person.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List { - writer.WriteStringValue(excludedDomainItem); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedPersonItem in person.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "organization": + var allowedVersionsForOrganization = new List { - writer.WriteStringValue(excludedPersonItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOrganization.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("givenName"u8); - writer.WriteStringValue(person.GivenName); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(person.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(person.IsActive); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(person.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(person.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("organization"u8); - - if(person.Organization.HasValue) + + if(value != null) { - writer.WriteStringValue(person.Organization.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } + break; + case "organizationalunit": + var allowedVersionsForOrganizationalUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOrganizationalUnit.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("organizationalUnit"u8); - writer.WriteStringValue(person.OrganizationalUnit); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "password": + var allowedVersionsForPassword = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPassword.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("password"u8); - writer.WriteStringValue(person.Password); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(person.RevisionNumber); - writer.WritePropertyName("role"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } - if(person.Role.HasValue) + break; + case "role": + var allowedVersionsForRole = new List { - writer.WriteStringValue(person.Role.Value); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRole.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("role"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } + break; + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(person.ShortName); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "surname": + var allowedVersionsForSurname = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSurname.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("surname"u8); - writer.WriteStringValue(person.Surname); - writer.WriteStartArray("telephoneNumber"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var telephoneNumberItem in person.TelephoneNumber.OrderBy(x => x, this.GuidComparer)) + break; + case "telephonenumber": + var allowedVersionsForTelephoneNumber = new List { - writer.WriteStringValue(telephoneNumberItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTelephoneNumber.Contains(requestedVersion)) + { + return; } + writer.WriteStartArray("telephoneNumber"u8); + + if(value is IEnumerable objectListTelephoneNumber) + { + foreach(var telephoneNumberItem in objectListTelephoneNumber.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(telephoneNumberItem); + } + } + writer.WriteEndArray(); + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "userpreference": + var allowedVersionsForUserPreference = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUserPreference.Contains(requestedVersion)) + { + return; + } + writer.WriteStartArray("userPreference"u8); - foreach(var userPreferenceItem in person.UserPreference.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListUserPreference) { - writer.WriteStringValue(userPreferenceItem); + foreach(var userPreferenceItem in objectListUserPreference.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(userPreferenceItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Person for Version 1.2.0"); + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the Person"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not Person person) + { + throw new ArgumentException("The thing shall be a Person", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Person since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Person for Version 1.0.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(person.ClassKind.ToString()); writer.WritePropertyName("defaultDomain"u8); @@ -350,25 +727,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in person.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in person.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - writer.WritePropertyName("givenName"u8); writer.WriteStringValue(person.GivenName); writer.WritePropertyName("iid"u8); @@ -377,8 +735,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteBooleanValue(person.IsActive); writer.WritePropertyName("isDeprecated"u8); writer.WriteBooleanValue(person.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(person.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("organization"u8); if(person.Organization.HasValue) @@ -419,9 +775,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(person.ThingPreference); writer.WriteStartArray("userPreference"u8); foreach(var userPreferenceItem in person.UserPreference.OrderBy(x => x, this.GuidComparer)) @@ -430,21 +783,9 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Person for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(person.Actor.HasValue) - { - writer.WriteStringValue(person.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Person for Version 1.1.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(person.ClassKind.ToString()); writer.WritePropertyName("defaultDomain"u8); @@ -488,7 +829,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in person.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -497,7 +837,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in person.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -506,7 +845,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("givenName"u8); writer.WriteStringValue(person.GivenName); writer.WritePropertyName("iid"u8); @@ -557,9 +895,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(person.ThingPreference); writer.WriteStartArray("userPreference"u8); foreach(var userPreferenceItem in person.UserPreference.OrderBy(x => x, this.GuidComparer)) @@ -568,477 +903,268 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Person for Version 1.2.0"); writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "defaultdomain": - if(!AllowedVersionsPerProperty["defaultDomain"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(person.ClassKind.ToString()); writer.WritePropertyName("defaultDomain"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "defaultemailaddress": - if(!AllowedVersionsPerProperty["defaultEmailAddress"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("defaultEmailAddress"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "defaulttelephonenumber": - if(!AllowedVersionsPerProperty["defaultTelephoneNumber"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("defaultTelephoneNumber"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "emailaddress": - if(!AllowedVersionsPerProperty["emailAddress"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("emailAddress"u8); - - if(value is IEnumerable objectListEmailAddress) - { - foreach(var emailAddressItem in objectListEmailAddress.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(emailAddressItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "givenname": - if(!AllowedVersionsPerProperty["givenName"].Contains(requestedVersion)) - { - return; - } - writer.WritePropertyName("givenName"u8); - - if(value != null) + if(person.DefaultDomain.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(person.DefaultDomain.Value); } else { writer.WriteNullValue(); } - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WritePropertyName("defaultEmailAddress"u8); + + if(person.DefaultEmailAddress.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(person.DefaultEmailAddress.Value); } else { writer.WriteNullValue(); } - break; - case "isactive": - if(!AllowedVersionsPerProperty["isActive"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("defaultTelephoneNumber"u8); - writer.WritePropertyName("isActive"u8); - - if(value != null) + if(person.DefaultTelephoneNumber.HasValue) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(person.DefaultTelephoneNumber.Value); } else { writer.WriteNullValue(); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("emailAddress"u8); - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + foreach(var emailAddressItem in person.EmailAddress.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(emailAddressItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in person.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in person.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WritePropertyName("givenName"u8); + writer.WriteStringValue(person.GivenName); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(person.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(person.IsActive); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(person.IsDeprecated); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteStringValue(person.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("organization"u8); + + if(person.Organization.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(person.Organization.Value); } else { writer.WriteNullValue(); } - break; - case "organization": - if(!AllowedVersionsPerProperty["organization"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("organizationalUnit"u8); + writer.WriteStringValue(person.OrganizationalUnit); + writer.WritePropertyName("password"u8); + writer.WriteStringValue(person.Password); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(person.RevisionNumber); + writer.WritePropertyName("role"u8); - writer.WritePropertyName("organization"u8); - - if(value != null) + if(person.Role.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(person.Role.Value); } else { writer.WriteNullValue(); } - break; - case "organizationalunit": - if(!AllowedVersionsPerProperty["organizationalUnit"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(person.ShortName); + writer.WritePropertyName("surname"u8); + writer.WriteStringValue(person.Surname); + writer.WriteStartArray("telephoneNumber"u8); - writer.WritePropertyName("organizationalUnit"u8); - - if(value != null) + foreach(var telephoneNumberItem in person.TelephoneNumber.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(telephoneNumberItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(person.ThingPreference); + writer.WriteStartArray("userPreference"u8); + + foreach(var userPreferenceItem in person.UserPreference.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(userPreferenceItem); } + writer.WriteEndArray(); break; - case "password": - if(!AllowedVersionsPerProperty["password"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Person for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("password"u8); - - if(value != null) + if(person.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(person.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(person.ClassKind.ToString()); + writer.WritePropertyName("defaultDomain"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(person.DefaultDomain.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(person.DefaultDomain.Value); } else { writer.WriteNullValue(); } - break; - case "role": - if(!AllowedVersionsPerProperty["role"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("defaultEmailAddress"u8); - writer.WritePropertyName("role"u8); - - if(value != null) + if(person.DefaultEmailAddress.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(person.DefaultEmailAddress.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("defaultTelephoneNumber"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) + if(person.DefaultTelephoneNumber.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(person.DefaultTelephoneNumber.Value); } else { writer.WriteNullValue(); } - break; - case "surname": - if(!AllowedVersionsPerProperty["surname"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("emailAddress"u8); - writer.WritePropertyName("surname"u8); - - if(value != null) + foreach(var emailAddressItem in person.EmailAddress.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(emailAddressItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in person.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "telephonenumber": - if(!AllowedVersionsPerProperty["telephoneNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in person.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WriteStartArray("telephoneNumber"u8); + writer.WriteEndArray(); + writer.WritePropertyName("givenName"u8); + writer.WriteStringValue(person.GivenName); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(person.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(person.IsActive); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(person.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(person.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("organization"u8); - if(value is IEnumerable objectListTelephoneNumber) + if(person.Organization.HasValue) { - foreach(var telephoneNumberItem in objectListTelephoneNumber.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(telephoneNumberItem); - } + writer.WriteStringValue(person.Organization.Value); } - - writer.WriteEndArray(); - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WritePropertyName("organizationalUnit"u8); + writer.WriteStringValue(person.OrganizationalUnit); + writer.WritePropertyName("password"u8); + writer.WriteStringValue(person.Password); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(person.RevisionNumber); + writer.WritePropertyName("role"u8); + + if(person.Role.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(person.Role.Value); } else { writer.WriteNullValue(); } - break; - case "userpreference": - if(!AllowedVersionsPerProperty["userPreference"].Contains(requestedVersion)) + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(person.ShortName); + writer.WritePropertyName("surname"u8); + writer.WriteStringValue(person.Surname); + writer.WriteStartArray("telephoneNumber"u8); + + foreach(var telephoneNumberItem in person.TelephoneNumber.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(telephoneNumberItem); } + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(person.ThingPreference); writer.WriteStartArray("userPreference"u8); - if(value is IEnumerable objectListUserPreference) + foreach(var userPreferenceItem in person.UserPreference.OrderBy(x => x, this.GuidComparer)) { - foreach(var userPreferenceItem in objectListUserPreference.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(userPreferenceItem); - } + writer.WriteStringValue(userPreferenceItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the Person"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "defaultDomain", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "defaultEmailAddress", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "defaultTelephoneNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "emailAddress", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "givenName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isActive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "organization", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "organizationalUnit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "password", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "role", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "surname", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "telephoneNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "userPreference", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/PointSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/PointSerializer.cs index 4140edf0..971c3903 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/PointSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/PointSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,158 +49,6 @@ namespace CDP4JsonSerializer /// public class PointSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Point point) - { - throw new ArgumentException("The thing shall be a Point", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Point since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Point for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(point.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in point.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in point.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(point.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(point.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(point.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(point.RevisionNumber); - writer.WritePropertyName("x"u8); - writer.WriteNumberValue(point.X); - writer.WritePropertyName("y"u8); - writer.WriteNumberValue(point.Y); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Point for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(point.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in point.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in point.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(point.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(point.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(point.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(point.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(point.ThingPreference); - writer.WritePropertyName("x"u8); - writer.WriteNumberValue(point.X); - writer.WritePropertyName("y"u8); - writer.WriteNumberValue(point.Y); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Point for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(point.Actor.HasValue) - { - writer.WriteStringValue(point.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(point.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in point.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in point.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(point.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(point.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(point.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(point.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(point.ThingPreference); - writer.WritePropertyName("x"u8); - writer.WriteNumberValue(point.X); - writer.WritePropertyName("y"u8); - writer.WriteNumberValue(point.Y); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -209,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -217,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -235,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -253,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -271,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -289,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -307,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -325,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -343,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -361,7 +261,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -379,7 +285,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "x": - if(!AllowedVersionsPerProperty["x"].Contains(requestedVersion)) + var allowedVersionsForX = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForX.Contains(requestedVersion)) { return; } @@ -397,7 +310,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "y": - if(!AllowedVersionsPerProperty["y"].Contains(requestedVersion)) + var allowedVersionsForY = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForY.Contains(requestedVersion)) { return; } @@ -420,22 +340,150 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "x", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "y", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not Point point) + { + throw new ArgumentException("The thing shall be a Point", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Point since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Point for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(point.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in point.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in point.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(point.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(point.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(point.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(point.RevisionNumber); + writer.WritePropertyName("x"u8); + writer.WriteNumberValue(point.X); + writer.WritePropertyName("y"u8); + writer.WriteNumberValue(point.Y); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Point for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(point.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in point.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in point.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(point.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(point.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(point.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(point.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(point.ThingPreference); + writer.WritePropertyName("x"u8); + writer.WriteNumberValue(point.X); + writer.WritePropertyName("y"u8); + writer.WriteNumberValue(point.Y); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Point for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(point.Actor.HasValue) + { + writer.WriteStringValue(point.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(point.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in point.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in point.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(point.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(point.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(point.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(point.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(point.ThingPreference); + writer.WritePropertyName("x"u8); + writer.WriteNumberValue(point.X); + writer.WritePropertyName("y"u8); + writer.WriteNumberValue(point.Y); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/PossibleFiniteStateListSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/PossibleFiniteStateListSerializer.cs index 4c5bea08..0d1cd3b8 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/PossibleFiniteStateListSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/PossibleFiniteStateListSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,252 +50,521 @@ namespace CDP4JsonSerializer public class PossibleFiniteStateListSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not PossibleFiniteStateList possibleFiniteStateList) - { - throw new ArgumentException("The thing shall be a PossibleFiniteStateList", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of PossibleFiniteStateList since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing PossibleFiniteStateList for Version 1.0.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in possibleFiniteStateList.Alias.OrderBy(x => x, this.GuidComparer)) + case "actor": + var allowedVersionsForActor = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + "1.3.0", + }; - foreach(var categoryItem in possibleFiniteStateList.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(possibleFiniteStateList.ClassKind.ToString()); - writer.WritePropertyName("defaultState"u8); - - if(possibleFiniteStateList.DefaultState.HasValue) + if(value != null) { - writer.WriteStringValue(possibleFiniteStateList.DefaultState.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in possibleFiniteStateList.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in possibleFiniteStateList.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(possibleFiniteStateList.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(possibleFiniteStateList.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(possibleFiniteStateList.Owner); - writer.WriteStartArray("possibleState"u8); + writer.WriteEndArray(); + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var possibleStateItem in possibleFiniteStateList.PossibleState.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteOrderedItem(possibleStateItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + if(value is IEnumerable objectListCategory) + { + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + } - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(possibleFiniteStateList.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(possibleFiniteStateList.ShortName); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing PossibleFiniteStateList for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in possibleFiniteStateList.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("category"u8); + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } - foreach(var categoryItem in possibleFiniteStateList.Category.OrderBy(x => x, this.GuidComparer)) + break; + case "defaultstate": + var allowedVersionsForDefaultState = new List { - writer.WriteStringValue(categoryItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefaultState.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(possibleFiniteStateList.ClassKind.ToString()); writer.WritePropertyName("defaultState"u8); - - if(possibleFiniteStateList.DefaultState.HasValue) + + if(value != null) { - writer.WriteStringValue(possibleFiniteStateList.DefaultState.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("definition"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in possibleFiniteStateList.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("definition"u8); - foreach(var excludedDomainItem in possibleFiniteStateList.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(excludedDomainItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in possibleFiniteStateList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var hyperLinkItem in possibleFiniteStateList.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(hyperLinkItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(possibleFiniteStateList.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(possibleFiniteStateList.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(possibleFiniteStateList.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(possibleFiniteStateList.Owner); - writer.WriteStartArray("possibleState"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var possibleStateItem in possibleFiniteStateList.PossibleState.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteOrderedItem(possibleStateItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(possibleFiniteStateList.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(possibleFiniteStateList.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing PossibleFiniteStateList for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in possibleFiniteStateList.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } - writer.WriteStartArray("category"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in possibleFiniteStateList.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(possibleFiniteStateList.ClassKind.ToString()); - writer.WritePropertyName("defaultState"u8); - - if(possibleFiniteStateList.DefaultState.HasValue) + if(value != null) { - writer.WriteStringValue(possibleFiniteStateList.DefaultState.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("definition"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in possibleFiniteStateList.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in possibleFiniteStateList.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("name"u8); - writer.WriteStartArray("excludedPerson"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedPersonItem in possibleFiniteStateList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "owner": + var allowedVersionsForOwner = new List { - writer.WriteStringValue(excludedPersonItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("owner"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "possiblestate": + var allowedVersionsForPossibleState = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPossibleState.Contains(requestedVersion)) + { + return; } + writer.WriteStartArray("possibleState"u8); + + if(value is IEnumerable objectListPossibleState) + { + foreach(var possibleStateItem in objectListPossibleState.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(possibleStateItem); + } + } + writer.WriteEndArray(); + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("shortName"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the PossibleFiniteStateList"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not PossibleFiniteStateList possibleFiniteStateList) + { + throw new ArgumentException("The thing shall be a PossibleFiniteStateList", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of PossibleFiniteStateList since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing PossibleFiniteStateList for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in possibleFiniteStateList.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in possibleFiniteStateList.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(possibleFiniteStateList.ClassKind.ToString()); + writer.WritePropertyName("defaultState"u8); + + if(possibleFiniteStateList.DefaultState.HasValue) + { + writer.WriteStringValue(possibleFiniteStateList.DefaultState.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in possibleFiniteStateList.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in possibleFiniteStateList.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -305,11 +573,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(possibleFiniteStateList.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(possibleFiniteStateList.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); writer.WriteStringValue(possibleFiniteStateList.Name); writer.WritePropertyName("owner"u8); @@ -322,27 +587,13 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(possibleFiniteStateList.RevisionNumber); writer.WritePropertyName("shortName"u8); writer.WriteStringValue(possibleFiniteStateList.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(possibleFiniteStateList.ThingPreference); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing PossibleFiniteStateList for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(possibleFiniteStateList.Actor.HasValue) - { - writer.WriteStringValue(possibleFiniteStateList.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing PossibleFiniteStateList for Version 1.1.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in possibleFiniteStateList.Alias.OrderBy(x => x, this.GuidComparer)) @@ -351,7 +602,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("category"u8); foreach(var categoryItem in possibleFiniteStateList.Category.OrderBy(x => x, this.GuidComparer)) @@ -360,7 +610,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(possibleFiniteStateList.ClassKind.ToString()); writer.WritePropertyName("defaultState"u8); @@ -382,7 +631,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in possibleFiniteStateList.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -391,7 +639,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in possibleFiniteStateList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -400,7 +647,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in possibleFiniteStateList.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -409,7 +655,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(possibleFiniteStateList.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -426,369 +671,200 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(possibleFiniteStateList.RevisionNumber); writer.WritePropertyName("shortName"u8); writer.WriteStringValue(possibleFiniteStateList.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(possibleFiniteStateList.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing PossibleFiniteStateList for Version 1.2.0"); + writer.WriteStartArray("alias"u8); - writer.WriteEndObject(); - } + foreach(var aliasItem in possibleFiniteStateList.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + foreach(var categoryItem in possibleFiniteStateList.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("actor"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(possibleFiniteStateList.ClassKind.ToString()); + writer.WritePropertyName("defaultState"u8); + + if(possibleFiniteStateList.DefaultState.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(possibleFiniteStateList.DefaultState.Value); } else { writer.WriteNullValue(); } - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + foreach(var definitionItem in possibleFiniteStateList.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) - { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - } - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } + writer.WriteStartArray("excludedDomain"u8); - break; - case "defaultstate": - if(!AllowedVersionsPerProperty["defaultState"].Contains(requestedVersion)) + foreach(var excludedDomainItem in possibleFiniteStateList.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("defaultState"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + foreach(var excludedPersonItem in possibleFiniteStateList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + foreach(var hyperLinkItem in possibleFiniteStateList.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("hyperLink"u8); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(possibleFiniteStateList.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(possibleFiniteStateList.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(possibleFiniteStateList.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(possibleFiniteStateList.Owner); + writer.WriteStartArray("possibleState"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var possibleStateItem in possibleFiniteStateList.PossibleState.OrderBy(x => x, this.OrderedItemComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteOrderedItem(possibleStateItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(possibleFiniteStateList.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(possibleFiniteStateList.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(possibleFiniteStateList.ThingPreference); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing PossibleFiniteStateList for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + if(possibleFiniteStateList.Actor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(possibleFiniteStateList.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else + foreach(var aliasItem in possibleFiniteStateList.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(aliasItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - writer.WritePropertyName("name"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else + foreach(var categoryItem in possibleFiniteStateList.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) - { - return; - } + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(possibleFiniteStateList.ClassKind.ToString()); + writer.WritePropertyName("defaultState"u8); - writer.WritePropertyName("owner"u8); - - if(value != null) + if(possibleFiniteStateList.DefaultState.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(possibleFiniteStateList.DefaultState.Value); } else { writer.WriteNullValue(); } - break; - case "possiblestate": - if(!AllowedVersionsPerProperty["possibleState"].Contains(requestedVersion)) + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in possibleFiniteStateList.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WriteStartArray("possibleState"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListPossibleState) + foreach(var excludedDomainItem in possibleFiniteStateList.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var possibleStateItem in objectListPossibleState.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(possibleStateItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("excludedPerson"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else + foreach(var excludedPersonItem in possibleFiniteStateList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else + foreach(var hyperLinkItem in possibleFiniteStateList.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(possibleFiniteStateList.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(possibleFiniteStateList.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(possibleFiniteStateList.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(possibleFiniteStateList.Owner); + writer.WriteStartArray("possibleState"u8); - writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else + foreach(var possibleStateItem in possibleFiniteStateList.PossibleState.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(possibleStateItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(possibleFiniteStateList.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(possibleFiniteStateList.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(possibleFiniteStateList.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the PossibleFiniteStateList"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "defaultState", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "possibleState", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/PossibleFiniteStateSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/PossibleFiniteStateSerializer.cs index 0d47f7b5..8829ee1b 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/PossibleFiniteStateSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/PossibleFiniteStateSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,6 +49,354 @@ namespace CDP4JsonSerializer /// public class PossibleFiniteStateSerializer : BaseThingSerializer, IThingSerializer { + /// + /// Serialize a value for a property into a + /// + /// The name of the property to serialize + /// The object value to serialize + /// The + /// The that has been requested for the serialization + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + var requestedVersion = requestedDataModelVersion.ToString(3); + + switch(propertyName.ToLower()) + { + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("alias"u8); + + if(value is IEnumerable objectListAlias) + { + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + } + + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("classKind"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } + + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefinition.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("definition"u8); + + if(value is IEnumerable objectListDefinition) + { + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + } + + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } + + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("name"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("shortName"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the PossibleFiniteState"); + } + } + /// /// Serializes a into an /// @@ -76,7 +423,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM switch(requestedDataModelVersion.ToString(3)) { case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing PossibleFiniteState for Version 1.0.0"); + Logger.Log(LogLevel.Debug, "Serializing PossibleFiniteState for Version 1.0.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in possibleFiniteState.Alias.OrderBy(x => x, this.GuidComparer)) @@ -85,7 +432,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(possibleFiniteState.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -96,7 +442,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in possibleFiniteState.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -105,7 +450,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(possibleFiniteState.Iid); writer.WritePropertyName("name"u8); @@ -116,7 +460,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(possibleFiniteState.ShortName); break; case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing PossibleFiniteState for Version 1.1.0"); + Logger.Log(LogLevel.Debug, "Serializing PossibleFiniteState for Version 1.1.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in possibleFiniteState.Alias.OrderBy(x => x, this.GuidComparer)) @@ -125,7 +469,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(possibleFiniteState.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -136,7 +479,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in possibleFiniteState.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -145,7 +487,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in possibleFiniteState.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -154,7 +495,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in possibleFiniteState.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -163,7 +503,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(possibleFiniteState.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -176,7 +515,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(possibleFiniteState.ShortName); break; case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing PossibleFiniteState for Version 1.2.0"); + Logger.Log(LogLevel.Debug, "Serializing PossibleFiniteState for Version 1.2.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in possibleFiniteState.Alias.OrderBy(x => x, this.GuidComparer)) @@ -185,7 +524,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(possibleFiniteState.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -196,7 +534,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in possibleFiniteState.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -205,7 +542,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in possibleFiniteState.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -214,7 +550,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in possibleFiniteState.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -223,7 +558,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(possibleFiniteState.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -238,7 +572,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(possibleFiniteState.ThingPreference); break; case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing PossibleFiniteState for Version 1.3.0"); + Logger.Log(LogLevel.Debug, "Serializing PossibleFiniteState for Version 1.3.0"); writer.WritePropertyName("actor"u8); if(possibleFiniteState.Actor.HasValue) @@ -258,7 +592,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(possibleFiniteState.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -269,7 +602,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in possibleFiniteState.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -278,7 +610,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in possibleFiniteState.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -287,7 +618,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in possibleFiniteState.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -296,7 +626,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(possibleFiniteState.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -316,279 +645,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteEndObject(); } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("name"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("shortName"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the PossibleFiniteState"); - } - } - - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/PrefixedUnitSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/PrefixedUnitSerializer.cs index 42104de7..f6ed496f 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/PrefixedUnitSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/PrefixedUnitSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,112 +50,424 @@ namespace CDP4JsonSerializer public class PrefixedUnitSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not PrefixedUnit prefixedUnit) - { - throw new ArgumentException("The thing shall be a PrefixedUnit", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.0.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of PrefixedUnit since Version is below 1.0.0"); - return; - } + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - writer.WriteStartObject(); + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing PrefixedUnit for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var aliasItem in prefixedUnit.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "alias": + var allowedVersionsForAlias = new List { - writer.WriteStringValue(aliasItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WriteStartArray("alias"u8); + + if(value is IEnumerable objectListAlias) + { + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + } + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(prefixedUnit.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } - foreach(var definitionItem in prefixedUnit.Definition.OrderBy(x => x, this.GuidComparer)) + break; + case "definition": + var allowedVersionsForDefinition = new List { - writer.WriteStringValue(definitionItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefinition.Contains(requestedVersion)) + { + return; } + writer.WriteStartArray("definition"u8); + + if(value is IEnumerable objectListDefinition) + { + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + } + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in prefixedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("iid"u8); - writer.WriteStringValue(prefixedUnit.Iid); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(prefixedUnit.IsDeprecated); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "prefix": + var allowedVersionsForPrefix = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPrefix.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("prefix"u8); - writer.WriteStringValue(prefixedUnit.Prefix); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "referenceunit": + var allowedVersionsForReferenceUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReferenceUnit.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("referenceUnit"u8); - writer.WriteStringValue(prefixedUnit.ReferenceUnit); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(prefixedUnit.RevisionNumber); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing PrefixedUnit for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in prefixedUnit.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(prefixedUnit.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var definitionItem in prefixedUnit.Definition.OrderBy(x => x, this.GuidComparer)) + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List { - writer.WriteStringValue(definitionItem); + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); - writer.WriteStartArray("excludedDomain"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedDomainItem in prefixedUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the PrefixedUnit"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not PrefixedUnit prefixedUnit) + { + throw new ArgumentException("The thing shall be a PrefixedUnit", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of PrefixedUnit since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing PrefixedUnit for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in prefixedUnit.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(aliasItem); } writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(prefixedUnit.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - foreach(var excludedPersonItem in prefixedUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + foreach(var definitionItem in prefixedUnit.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(definitionItem); } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in prefixedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -165,13 +476,10 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(prefixedUnit.Iid); writer.WritePropertyName("isDeprecated"u8); writer.WriteBooleanValue(prefixedUnit.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(prefixedUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("prefix"u8); writer.WriteStringValue(prefixedUnit.Prefix); writer.WritePropertyName("referenceUnit"u8); @@ -179,8 +487,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(prefixedUnit.RevisionNumber); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing PrefixedUnit for Version 1.2.0"); + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing PrefixedUnit for Version 1.1.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in prefixedUnit.Alias.OrderBy(x => x, this.GuidComparer)) @@ -189,7 +497,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(prefixedUnit.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -200,7 +507,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in prefixedUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -209,7 +515,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in prefixedUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -218,7 +523,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in prefixedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -227,7 +531,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(prefixedUnit.Iid); writer.WritePropertyName("isDeprecated"u8); @@ -240,22 +543,9 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteStringValue(prefixedUnit.ReferenceUnit); writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(prefixedUnit.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(prefixedUnit.ThingPreference); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing PrefixedUnit for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(prefixedUnit.Actor.HasValue) - { - writer.WriteStringValue(prefixedUnit.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing PrefixedUnit for Version 1.2.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in prefixedUnit.Alias.OrderBy(x => x, this.GuidComparer)) @@ -264,7 +554,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(prefixedUnit.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -275,7 +564,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in prefixedUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -284,7 +572,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in prefixedUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -293,7 +580,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in prefixedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -302,7 +588,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(prefixedUnit.Iid); writer.WritePropertyName("isDeprecated"u8); @@ -318,304 +603,82 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WritePropertyName("thingPreference"u8); writer.WriteStringValue(prefixedUnit.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing PrefixedUnit for Version 1.3.0"); writer.WritePropertyName("actor"u8); - - if(value != null) + + if(prefixedUnit.Actor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(prefixedUnit.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - writer.WriteStartArray("alias"u8); - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + foreach(var aliasItem in prefixedUnit.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } + writer.WriteEndArray(); writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(prefixedUnit.ClassKind.ToString()); writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + foreach(var definitionItem in prefixedUnit.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + foreach(var excludedDomainItem in prefixedUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + foreach(var excludedPersonItem in prefixedUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + foreach(var hyperLinkItem in prefixedUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(prefixedUnit.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - + writer.WriteBooleanValue(prefixedUnit.IsDeprecated); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "prefix": - if(!AllowedVersionsPerProperty["prefix"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(prefixedUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("prefix"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "referenceunit": - if(!AllowedVersionsPerProperty["referenceUnit"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(prefixedUnit.Prefix); writer.WritePropertyName("referenceUnit"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(prefixedUnit.ReferenceUnit); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - + writer.WriteNumberValue(prefixedUnit.RevisionNumber); writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - + writer.WriteStringValue(prefixedUnit.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the PrefixedUnit"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "prefix", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "referenceUnit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/PublicationSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/PublicationSerializer.cs index d1beffcf..69e006ce 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/PublicationSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/PublicationSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,229 +49,6 @@ namespace CDP4JsonSerializer /// public class PublicationSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Publication publication) - { - throw new ArgumentException("The thing shall be a Publication", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Publication since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Publication for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(publication.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(publication.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("domain"u8); - - foreach(var domainItem in publication.Domain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(publication.Iid); - writer.WriteStartArray("publishedParameter"u8); - - foreach(var publishedParameterItem in publication.PublishedParameter.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(publishedParameterItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(publication.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Publication for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(publication.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(publication.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("domain"u8); - - foreach(var domainItem in publication.Domain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in publication.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in publication.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(publication.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(publication.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("publishedParameter"u8); - - foreach(var publishedParameterItem in publication.PublishedParameter.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(publishedParameterItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(publication.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Publication for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(publication.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(publication.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("domain"u8); - - foreach(var domainItem in publication.Domain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in publication.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in publication.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(publication.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(publication.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("publishedParameter"u8); - - foreach(var publishedParameterItem in publication.PublishedParameter.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(publishedParameterItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(publication.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(publication.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Publication for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(publication.Actor.HasValue) - { - writer.WriteStringValue(publication.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(publication.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(publication.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("domain"u8); - - foreach(var domainItem in publication.Domain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in publication.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in publication.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(publication.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(publication.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("publishedParameter"u8); - - foreach(var publishedParameterItem in publication.PublishedParameter.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(publishedParameterItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(publication.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(publication.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -280,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -288,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -306,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -324,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -342,7 +138,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "domain": - if(!AllowedVersionsPerProperty["domain"].Contains(requestedVersion)) + var allowedVersionsForDomain = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDomain.Contains(requestedVersion)) { return; } @@ -360,7 +164,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -378,7 +189,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -396,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -414,7 +240,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -432,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "publishedparameter": - if(!AllowedVersionsPerProperty["publishedParameter"].Contains(requestedVersion)) + var allowedVersionsForPublishedParameter = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPublishedParameter.Contains(requestedVersion)) { return; } @@ -450,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -468,7 +317,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -491,22 +346,213 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "domain", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "publishedParameter", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Publication publication) + { + throw new ArgumentException("The thing shall be a Publication", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Publication since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Publication for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(publication.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(publication.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in publication.Domain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(publication.Iid); + writer.WriteStartArray("publishedParameter"u8); + + foreach(var publishedParameterItem in publication.PublishedParameter.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(publishedParameterItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(publication.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Publication for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(publication.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(publication.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in publication.Domain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in publication.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in publication.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(publication.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(publication.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("publishedParameter"u8); + + foreach(var publishedParameterItem in publication.PublishedParameter.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(publishedParameterItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(publication.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Publication for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(publication.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(publication.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in publication.Domain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in publication.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in publication.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(publication.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(publication.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("publishedParameter"u8); + + foreach(var publishedParameterItem in publication.PublishedParameter.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(publishedParameterItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(publication.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(publication.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Publication for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(publication.Actor.HasValue) + { + writer.WriteStringValue(publication.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(publication.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(publication.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in publication.Domain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in publication.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in publication.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(publication.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(publication.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("publishedParameter"u8); + + foreach(var publishedParameterItem in publication.PublishedParameter.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(publishedParameterItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(publication.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(publication.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/QuantityKindFactorSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/QuantityKindFactorSerializer.cs index 966d9d81..0519f1a2 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/QuantityKindFactorSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/QuantityKindFactorSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,165 +49,6 @@ namespace CDP4JsonSerializer /// public class QuantityKindFactorSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not QuantityKindFactor quantityKindFactor) - { - throw new ArgumentException("The thing shall be a QuantityKindFactor", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of QuantityKindFactor since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing QuantityKindFactor for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(quantityKindFactor.ClassKind.ToString()); - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(quantityKindFactor.Exponent); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(quantityKindFactor.Iid); - writer.WritePropertyName("quantityKind"u8); - writer.WriteStringValue(quantityKindFactor.QuantityKind); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(quantityKindFactor.RevisionNumber); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing QuantityKindFactor for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(quantityKindFactor.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in quantityKindFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in quantityKindFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(quantityKindFactor.Exponent); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(quantityKindFactor.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(quantityKindFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("quantityKind"u8); - writer.WriteStringValue(quantityKindFactor.QuantityKind); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(quantityKindFactor.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing QuantityKindFactor for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(quantityKindFactor.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in quantityKindFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in quantityKindFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(quantityKindFactor.Exponent); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(quantityKindFactor.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(quantityKindFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("quantityKind"u8); - writer.WriteStringValue(quantityKindFactor.QuantityKind); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(quantityKindFactor.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(quantityKindFactor.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing QuantityKindFactor for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(quantityKindFactor.Actor.HasValue) - { - writer.WriteStringValue(quantityKindFactor.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(quantityKindFactor.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in quantityKindFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in quantityKindFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(quantityKindFactor.Exponent); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(quantityKindFactor.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(quantityKindFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("quantityKind"u8); - writer.WriteStringValue(quantityKindFactor.QuantityKind); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(quantityKindFactor.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(quantityKindFactor.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -216,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -224,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -242,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -260,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -278,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -296,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "exponent": - if(!AllowedVersionsPerProperty["exponent"].Contains(requestedVersion)) + var allowedVersionsForExponent = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExponent.Contains(requestedVersion)) { return; } @@ -314,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -332,7 +214,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -350,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "quantitykind": - if(!AllowedVersionsPerProperty["quantityKind"].Contains(requestedVersion)) + var allowedVersionsForQuantityKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForQuantityKind.Contains(requestedVersion)) { return; } @@ -368,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -386,7 +291,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -409,21 +320,157 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "exponent", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "quantityKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not QuantityKindFactor quantityKindFactor) + { + throw new ArgumentException("The thing shall be a QuantityKindFactor", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of QuantityKindFactor since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing QuantityKindFactor for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(quantityKindFactor.ClassKind.ToString()); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(quantityKindFactor.Exponent); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(quantityKindFactor.Iid); + writer.WritePropertyName("quantityKind"u8); + writer.WriteStringValue(quantityKindFactor.QuantityKind); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(quantityKindFactor.RevisionNumber); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing QuantityKindFactor for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(quantityKindFactor.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in quantityKindFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in quantityKindFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(quantityKindFactor.Exponent); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(quantityKindFactor.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(quantityKindFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("quantityKind"u8); + writer.WriteStringValue(quantityKindFactor.QuantityKind); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(quantityKindFactor.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing QuantityKindFactor for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(quantityKindFactor.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in quantityKindFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in quantityKindFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(quantityKindFactor.Exponent); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(quantityKindFactor.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(quantityKindFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("quantityKind"u8); + writer.WriteStringValue(quantityKindFactor.QuantityKind); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(quantityKindFactor.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(quantityKindFactor.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing QuantityKindFactor for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(quantityKindFactor.Actor.HasValue) + { + writer.WriteStringValue(quantityKindFactor.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(quantityKindFactor.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in quantityKindFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in quantityKindFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(quantityKindFactor.Exponent); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(quantityKindFactor.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(quantityKindFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("quantityKind"u8); + writer.WriteStringValue(quantityKindFactor.QuantityKind); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(quantityKindFactor.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(quantityKindFactor.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/RatioScaleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/RatioScaleSerializer.cs index b7edfc24..4ad6a83b 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/RatioScaleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/RatioScaleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,441 +50,292 @@ namespace CDP4JsonSerializer public class RatioScaleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not RatioScale ratioScale) - { - throw new ArgumentException("The thing shall be a RatioScale", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of RatioScale since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing RatioScale for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in ratioScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ratioScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in ratioScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in ratioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ratioScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(ratioScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(ratioScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(ratioScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var mappingToReferenceScaleItem in ratioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(mappingToReferenceScaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(ratioScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(ratioScale.MinimumPermissibleValue); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ratioScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(ratioScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(ratioScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(ratioScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ratioScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ratioScale.ShortName); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(ratioScale.Unit); - writer.WriteStartArray("valueDefinition"u8); + writer.WriteStartArray("alias"u8); - foreach(var valueDefinitionItem in ratioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(valueDefinitionItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing RatioScale for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in ratioScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ratioScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in ratioScale.Definition.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in ratioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in ratioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in ratioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ratioScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(ratioScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(ratioScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(ratioScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var mappingToReferenceScaleItem in ratioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(mappingToReferenceScaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(ratioScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(ratioScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ratioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ratioScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(ratioScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(ratioScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(ratioScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ratioScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ratioScale.ShortName); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(ratioScale.Unit); - writer.WriteStartArray("valueDefinition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var valueDefinitionItem in ratioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(valueDefinitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing RatioScale for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in ratioScale.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ratioScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var definitionItem in ratioScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(definitionItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in ratioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var excludedPersonItem in ratioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(excludedPersonItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in ratioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ratioScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(ratioScale.IsDeprecated); - writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(ratioScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(ratioScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); - - foreach(var mappingToReferenceScaleItem in ratioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(mappingToReferenceScaleItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(ratioScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(ratioScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ratioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ratioScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(ratioScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(ratioScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(ratioScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ratioScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ratioScale.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(ratioScale.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(ratioScale.Unit); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in ratioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueDefinitionItem); - } - - writer.WriteEndArray(); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing RatioScale for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(ratioScale.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(ratioScale.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in ratioScale.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ratioScale.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in ratioScale.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in ratioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in ratioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "ismaximuminclusive": + var allowedVersionsForIsMaximumInclusive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in ratioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsMaximumInclusive.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ratioScale.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(ratioScale.IsDeprecated); writer.WritePropertyName("isMaximumInclusive"u8); - writer.WriteBooleanValue(ratioScale.IsMaximumInclusive); - writer.WritePropertyName("isMinimumInclusive"u8); - writer.WriteBooleanValue(ratioScale.IsMinimumInclusive); - writer.WriteStartArray("mappingToReferenceScale"u8); - - foreach(var mappingToReferenceScaleItem in ratioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(mappingToReferenceScaleItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("maximumPermissibleValue"u8); - writer.WriteStringValue(ratioScale.MaximumPermissibleValue); - writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteStringValue(ratioScale.MinimumPermissibleValue); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ratioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ratioScale.Name); - writer.WritePropertyName("negativeValueConnotation"u8); - writer.WriteStringValue(ratioScale.NegativeValueConnotation); - writer.WritePropertyName("numberSet"u8); - writer.WriteStringValue(ratioScale.NumberSet.ToString()); - writer.WritePropertyName("positiveValueConnotation"u8); - writer.WriteStringValue(ratioScale.PositiveValueConnotation); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ratioScale.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ratioScale.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(ratioScale.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(ratioScale.Unit); - writer.WriteStartArray("valueDefinition"u8); - - foreach(var valueDefinitionItem in ratioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(valueDefinitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "isminimuminclusive": + var allowedVersionsForIsMinimumInclusive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForIsMinimumInclusive.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("isMinimumInclusive"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteBooleanValue((bool)value); } else { @@ -493,35 +343,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "mappingtoreferencescale": + var allowedVersionsForMappingToReferenceScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMappingToReferenceScale.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("mappingToReferenceScale"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListMappingToReferenceScale) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var mappingToReferenceScaleItem in objectListMappingToReferenceScale.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteStringValue(mappingToReferenceScaleItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "maximumpermissiblevalue": + var allowedVersionsForMaximumPermissibleValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMaximumPermissibleValue.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("maximumPermissibleValue"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -529,89 +395,50 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "minimumpermissiblevalue": + var allowedVersionsForMinimumPermissibleValue = new List { - return; - } - - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForMinimumPermissibleValue.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } + writer.WritePropertyName("minimumPermissibleValue"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List { - return; - } - - writer.WriteStartArray("hyperLink"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -619,17 +446,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isDeprecated"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -637,17 +472,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "ismaximuminclusive": - if(!AllowedVersionsPerProperty["isMaximumInclusive"].Contains(requestedVersion)) + case "negativevalueconnotation": + var allowedVersionsForNegativeValueConnotation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNegativeValueConnotation.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isMaximumInclusive"u8); + writer.WritePropertyName("negativeValueConnotation"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -655,17 +498,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isminimuminclusive": - if(!AllowedVersionsPerProperty["isMinimumInclusive"].Contains(requestedVersion)) + case "numberset": + var allowedVersionsForNumberSet = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForNumberSet.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isMinimumInclusive"u8); + writer.WritePropertyName("numberSet"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(((NumberSetKind)value).ToString()); } else { @@ -673,31 +524,21 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "mappingtoreferencescale": - if(!AllowedVersionsPerProperty["mappingToReferenceScale"].Contains(requestedVersion)) + case "positivevalueconnotation": + var allowedVersionsForPositiveValueConnotation = new List { - return; - } - - writer.WriteStartArray("mappingToReferenceScale"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListMappingToReferenceScale) - { - foreach(var mappingToReferenceScaleItem in objectListMappingToReferenceScale.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(mappingToReferenceScaleItem); - } - } - - writer.WriteEndArray(); - break; - case "maximumpermissiblevalue": - if(!AllowedVersionsPerProperty["maximumPermissibleValue"].Contains(requestedVersion)) + if(!allowedVersionsForPositiveValueConnotation.Contains(requestedVersion)) { return; } - writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WritePropertyName("positiveValueConnotation"u8); if(value != null) { @@ -709,17 +550,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "minimumpermissiblevalue": - if(!AllowedVersionsPerProperty["minimumPermissibleValue"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue((int)value); } else { @@ -727,17 +576,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((string)value); } else { @@ -745,13 +602,19 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("name"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { @@ -763,17 +626,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "negativevalueconnotation": - if(!AllowedVersionsPerProperty["negativeValueConnotation"].Contains(requestedVersion)) + case "unit": + var allowedVersionsForUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUnit.Contains(requestedVersion)) { return; } - writer.WritePropertyName("negativeValueConnotation"u8); + writer.WritePropertyName("unit"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue((Guid)value); } else { @@ -781,167 +652,421 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "numberset": - if(!AllowedVersionsPerProperty["numberSet"].Contains(requestedVersion)) + case "valuedefinition": + var allowedVersionsForValueDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueDefinition.Contains(requestedVersion)) { return; } - writer.WritePropertyName("numberSet"u8); + writer.WriteStartArray("valueDefinition"u8); + + if(value is IEnumerable objectListValueDefinition) + { + foreach(var valueDefinitionItem in objectListValueDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueDefinitionItem); + } + } - if(value != null) + writer.WriteEndArray(); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the RatioScale"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not RatioScale ratioScale) + { + throw new ArgumentException("The thing shall be a RatioScale", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of RatioScale since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing RatioScale for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in ratioScale.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((NumberSetKind)value).ToString()); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ratioScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in ratioScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "positivevalueconnotation": - if(!AllowedVersionsPerProperty["positiveValueConnotation"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in ratioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("positiveValueConnotation"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ratioScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(ratioScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(ratioScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(ratioScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in ratioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(mappingToReferenceScaleItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(ratioScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(ratioScale.MinimumPermissibleValue); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ratioScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(ratioScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(ratioScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(ratioScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ratioScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ratioScale.ShortName); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(ratioScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in ratioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(valueDefinitionItem); } + writer.WriteEndArray(); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing RatioScale for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in ratioScale.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ratioScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in ratioScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ratioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ratioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in ratioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ratioScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(ratioScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(ratioScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(ratioScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in ratioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(mappingToReferenceScaleItem); } + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(ratioScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(ratioScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ratioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ratioScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(ratioScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(ratioScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(ratioScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ratioScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ratioScale.ShortName); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(ratioScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in ratioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(valueDefinitionItem); + } + + writer.WriteEndArray(); break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing RatioScale for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in ratioScale.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ratioScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in ratioScale.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ratioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "unit": - if(!AllowedVersionsPerProperty["unit"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ratioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in ratioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ratioScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(ratioScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(ratioScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(ratioScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in ratioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(mappingToReferenceScaleItem); } + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(ratioScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(ratioScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ratioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ratioScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(ratioScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(ratioScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(ratioScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ratioScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ratioScale.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(ratioScale.ThingPreference); writer.WritePropertyName("unit"u8); - - if(value != null) + writer.WriteStringValue(ratioScale.Unit); + writer.WriteStartArray("valueDefinition"u8); + + foreach(var valueDefinitionItem in ratioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(valueDefinitionItem); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing RatioScale for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(ratioScale.Actor.HasValue) + { + writer.WriteStringValue(ratioScale.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "valuedefinition": - if(!AllowedVersionsPerProperty["valueDefinition"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in ratioScale.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ratioScale.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in ratioScale.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ratioScale.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ratioScale.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in ratioScale.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ratioScale.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(ratioScale.IsDeprecated); + writer.WritePropertyName("isMaximumInclusive"u8); + writer.WriteBooleanValue(ratioScale.IsMaximumInclusive); + writer.WritePropertyName("isMinimumInclusive"u8); + writer.WriteBooleanValue(ratioScale.IsMinimumInclusive); + writer.WriteStartArray("mappingToReferenceScale"u8); + + foreach(var mappingToReferenceScaleItem in ratioScale.MappingToReferenceScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(mappingToReferenceScaleItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("maximumPermissibleValue"u8); + writer.WriteStringValue(ratioScale.MaximumPermissibleValue); + writer.WritePropertyName("minimumPermissibleValue"u8); + writer.WriteStringValue(ratioScale.MinimumPermissibleValue); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ratioScale.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ratioScale.Name); + writer.WritePropertyName("negativeValueConnotation"u8); + writer.WriteStringValue(ratioScale.NegativeValueConnotation); + writer.WritePropertyName("numberSet"u8); + writer.WriteStringValue(ratioScale.NumberSet.ToString()); + writer.WritePropertyName("positiveValueConnotation"u8); + writer.WriteStringValue(ratioScale.PositiveValueConnotation); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ratioScale.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ratioScale.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(ratioScale.ThingPreference); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(ratioScale.Unit); writer.WriteStartArray("valueDefinition"u8); - if(value is IEnumerable objectListValueDefinition) + foreach(var valueDefinitionItem in ratioScale.ValueDefinition.OrderBy(x => x, this.GuidComparer)) { - foreach(var valueDefinitionItem in objectListValueDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueDefinitionItem); - } + writer.WriteStringValue(valueDefinitionItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the RatioScale"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isMaximumInclusive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isMinimumInclusive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "mappingToReferenceScale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "maximumPermissibleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "minimumPermissibleValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "negativeValueConnotation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "numberSet", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "positiveValueConnotation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "unit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "valueDefinition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ReferenceSourceSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ReferenceSourceSerializer.cs index c0b47518..d8669124 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ReferenceSourceSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ReferenceSourceSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,254 +50,614 @@ namespace CDP4JsonSerializer public class ReferenceSourceSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ReferenceSource referenceSource) - { - throw new ArgumentException("The thing shall be a ReferenceSource", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.0.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of ReferenceSource since Version is below 1.0.0"); - return; - } + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - writer.WriteStartObject(); + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ReferenceSource for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var aliasItem in referenceSource.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "alias": + var allowedVersionsForAlias = new List { - writer.WriteStringValue(aliasItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WriteStartArray("alias"u8); + + if(value is IEnumerable objectListAlias) + { + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + } + writer.WriteEndArray(); + break; + case "author": + var allowedVersionsForAuthor = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAuthor.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("author"u8); - writer.WriteStringValue(referenceSource.Author); - writer.WriteStartArray("category"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var categoryItem in referenceSource.Category.OrderBy(x => x, this.GuidComparer)) + break; + case "category": + var allowedVersionsForCategory = new List { - writer.WriteStringValue(categoryItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + if(value is IEnumerable objectListCategory) + { + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + } + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(referenceSource.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } - foreach(var definitionItem in referenceSource.Definition.OrderBy(x => x, this.GuidComparer)) + break; + case "definition": + var allowedVersionsForDefinition = new List { - writer.WriteStringValue(definitionItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefinition.Contains(requestedVersion)) + { + return; } + writer.WriteStartArray("definition"u8); + + if(value is IEnumerable objectListDefinition) + { + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + } + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in referenceSource.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(referenceSource.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(referenceSource.IsDeprecated); - writer.WritePropertyName("language"u8); - writer.WriteStringValue(referenceSource.Language); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(referenceSource.Name); - writer.WritePropertyName("publicationYear"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(referenceSource.PublicationYear.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteNumberValue(referenceSource.PublicationYear.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("publishedIn"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(referenceSource.PublishedIn.HasValue) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(referenceSource.PublishedIn.Value); + return; + } + + writer.WritePropertyName("isDeprecated"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("publisher"u8); + break; + case "language": + var allowedVersionsForLanguage = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(referenceSource.Publisher.HasValue) + if(!allowedVersionsForLanguage.Contains(requestedVersion)) { - writer.WriteStringValue(referenceSource.Publisher.Value); + return; + } + + writer.WritePropertyName("language"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(referenceSource.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(referenceSource.ShortName); - writer.WritePropertyName("versionDate"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(referenceSource.VersionDate.HasValue) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(referenceSource.VersionDate.Value.ToString(SerializerHelper.DateTimeFormat)); + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WritePropertyName("versionIdentifier"u8); - writer.WriteStringValue(referenceSource.VersionIdentifier); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ReferenceSource for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in referenceSource.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(referenceSource.Author); - writer.WriteStartArray("category"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var categoryItem in referenceSource.Category.OrderBy(x => x, this.GuidComparer)) + break; + case "publicationyear": + var allowedVersionsForPublicationYear = new List { - writer.WriteStringValue(categoryItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPublicationYear.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("publicationYear"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(referenceSource.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var definitionItem in referenceSource.Definition.OrderBy(x => x, this.GuidComparer)) + break; + case "publishedin": + var allowedVersionsForPublishedIn = new List { - writer.WriteStringValue(definitionItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPublishedIn.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("publishedIn"u8); - writer.WriteStartArray("excludedDomain"u8); + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedDomainItem in referenceSource.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + case "publisher": + var allowedVersionsForPublisher = new List { - writer.WriteStringValue(excludedDomainItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPublisher.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("publisher"u8); - writer.WriteStartArray("excludedPerson"u8); + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedPersonItem in referenceSource.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - writer.WriteStringValue(excludedPersonItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); - writer.WriteStartArray("hyperLink"u8); + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var hyperLinkItem in referenceSource.HyperLink.OrderBy(x => x, this.GuidComparer)) + break; + case "shortname": + var allowedVersionsForShortName = new List { - writer.WriteStringValue(hyperLinkItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(referenceSource.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(referenceSource.IsDeprecated); - writer.WritePropertyName("language"u8); - writer.WriteStringValue(referenceSource.Language); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(referenceSource.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(referenceSource.Name); - writer.WritePropertyName("publicationYear"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - if(referenceSource.PublicationYear.HasValue) + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List { - writer.WriteNumberValue(referenceSource.PublicationYear.Value); + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("publishedIn"u8); + break; + case "versiondate": + var allowedVersionsForVersionDate = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(referenceSource.PublishedIn.HasValue) + if(!allowedVersionsForVersionDate.Contains(requestedVersion)) { - writer.WriteStringValue(referenceSource.PublishedIn.Value); + return; + } + + writer.WritePropertyName("versionDate"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WritePropertyName("publisher"u8); + break; + case "versionidentifier": + var allowedVersionsForVersionIdentifier = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(referenceSource.Publisher.HasValue) + if(!allowedVersionsForVersionIdentifier.Contains(requestedVersion)) { - writer.WriteStringValue(referenceSource.Publisher.Value); + return; + } + + writer.WritePropertyName("versionIdentifier"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(referenceSource.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(referenceSource.ShortName); - writer.WritePropertyName("versionDate"u8); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ReferenceSource"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ReferenceSource referenceSource) + { + throw new ArgumentException("The thing shall be a ReferenceSource", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ReferenceSource since Version is below 1.0.0"); + return; + } - if(referenceSource.VersionDate.HasValue) - { - writer.WriteStringValue(referenceSource.VersionDate.Value.ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } + writer.WriteStartObject(); - writer.WritePropertyName("versionIdentifier"u8); - writer.WriteStringValue(referenceSource.VersionIdentifier); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ReferenceSource for Version 1.2.0"); + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ReferenceSource for Version 1.0.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in referenceSource.Alias.OrderBy(x => x, this.GuidComparer)) @@ -307,7 +666,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("author"u8); writer.WriteStringValue(referenceSource.Author); writer.WriteStartArray("category"u8); @@ -318,7 +676,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(referenceSource.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -329,25 +686,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in referenceSource.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in referenceSource.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in referenceSource.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -356,15 +694,12 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(referenceSource.Iid); writer.WritePropertyName("isDeprecated"u8); writer.WriteBooleanValue(referenceSource.IsDeprecated); writer.WritePropertyName("language"u8); writer.WriteStringValue(referenceSource.Language); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(referenceSource.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); writer.WriteStringValue(referenceSource.Name); writer.WritePropertyName("publicationYear"u8); @@ -404,8 +739,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNumberValue(referenceSource.RevisionNumber); writer.WritePropertyName("shortName"u8); writer.WriteStringValue(referenceSource.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(referenceSource.ThingPreference); writer.WritePropertyName("versionDate"u8); if(referenceSource.VersionDate.HasValue) @@ -420,19 +753,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WritePropertyName("versionIdentifier"u8); writer.WriteStringValue(referenceSource.VersionIdentifier); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ReferenceSource for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(referenceSource.Actor.HasValue) - { - writer.WriteStringValue(referenceSource.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ReferenceSource for Version 1.1.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in referenceSource.Alias.OrderBy(x => x, this.GuidComparer)) @@ -441,7 +763,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("author"u8); writer.WriteStringValue(referenceSource.Author); writer.WriteStartArray("category"u8); @@ -452,7 +773,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(referenceSource.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -463,7 +783,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in referenceSource.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -472,7 +791,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in referenceSource.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -481,7 +799,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in referenceSource.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -490,7 +807,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(referenceSource.Iid); writer.WritePropertyName("isDeprecated"u8); @@ -538,472 +854,271 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNumberValue(referenceSource.RevisionNumber); writer.WritePropertyName("shortName"u8); writer.WriteStringValue(referenceSource.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(referenceSource.ThingPreference); writer.WritePropertyName("versionDate"u8); if(referenceSource.VersionDate.HasValue) { - writer.WriteStringValue(referenceSource.VersionDate.Value.ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("versionIdentifier"u8); - writer.WriteStringValue(referenceSource.VersionIdentifier); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("author"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) - { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(referenceSource.VersionDate.Value.ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } + writer.WritePropertyName("versionIdentifier"u8); + writer.WriteStringValue(referenceSource.VersionIdentifier); break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) - { - return; - } + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ReferenceSource for Version 1.2.0"); + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + foreach(var aliasItem in referenceSource.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(referenceSource.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in referenceSource.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "language": - if(!AllowedVersionsPerProperty["language"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(referenceSource.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in referenceSource.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("language"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in referenceSource.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in referenceSource.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in referenceSource.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(referenceSource.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(referenceSource.IsDeprecated); + writer.WritePropertyName("language"u8); + writer.WriteStringValue(referenceSource.Language); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteStringValue(referenceSource.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(referenceSource.Name); + writer.WritePropertyName("publicationYear"u8); + + if(referenceSource.PublicationYear.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteNumberValue(referenceSource.PublicationYear.Value); } else { writer.WriteNullValue(); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("publishedIn"u8); - writer.WritePropertyName("name"u8); - - if(value != null) + if(referenceSource.PublishedIn.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(referenceSource.PublishedIn.Value); } else { writer.WriteNullValue(); } - break; - case "publicationyear": - if(!AllowedVersionsPerProperty["publicationYear"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("publisher"u8); - writer.WritePropertyName("publicationYear"u8); - - if(value != null) + if(referenceSource.Publisher.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(referenceSource.Publisher.Value); } else { writer.WriteNullValue(); } - break; - case "publishedin": - if(!AllowedVersionsPerProperty["publishedIn"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(referenceSource.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(referenceSource.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(referenceSource.ThingPreference); + writer.WritePropertyName("versionDate"u8); - writer.WritePropertyName("publishedIn"u8); - - if(value != null) + if(referenceSource.VersionDate.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(referenceSource.VersionDate.Value.ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } + writer.WritePropertyName("versionIdentifier"u8); + writer.WriteStringValue(referenceSource.VersionIdentifier); break; - case "publisher": - if(!AllowedVersionsPerProperty["publisher"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ReferenceSource for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("publisher"u8); - - if(value != null) + if(referenceSource.Actor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(referenceSource.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + foreach(var aliasItem in referenceSource.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(referenceSource.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in referenceSource.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(referenceSource.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in referenceSource.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in referenceSource.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in referenceSource.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in referenceSource.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(referenceSource.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(referenceSource.IsDeprecated); + writer.WritePropertyName("language"u8); + writer.WriteStringValue(referenceSource.Language); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(referenceSource.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(referenceSource.Name); + writer.WritePropertyName("publicationYear"u8); + + if(referenceSource.PublicationYear.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue(referenceSource.PublicationYear.Value); } else { writer.WriteNullValue(); } - break; - case "versiondate": - if(!AllowedVersionsPerProperty["versionDate"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("publishedIn"u8); - writer.WritePropertyName("versionDate"u8); - - if(value != null) + if(referenceSource.PublishedIn.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(referenceSource.PublishedIn.Value); } else { writer.WriteNullValue(); } - break; - case "versionidentifier": - if(!AllowedVersionsPerProperty["versionIdentifier"].Contains(requestedVersion)) + writer.WritePropertyName("publisher"u8); + + if(referenceSource.Publisher.HasValue) { - return; + writer.WriteStringValue(referenceSource.Publisher.Value); + } + else + { + writer.WriteNullValue(); } - writer.WritePropertyName("versionIdentifier"u8); - - if(value != null) + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(referenceSource.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(referenceSource.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(referenceSource.ThingPreference); + writer.WritePropertyName("versionDate"u8); + + if(referenceSource.VersionDate.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(referenceSource.VersionDate.Value.ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } + writer.WritePropertyName("versionIdentifier"u8); + writer.WriteStringValue(referenceSource.VersionIdentifier); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ReferenceSource"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "author", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "language", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "publicationYear", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "publishedIn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "publisher", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "versionDate", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "versionIdentifier", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ReferencerRuleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ReferencerRuleSerializer.cs index 36b9ef62..48553ff2 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ReferencerRuleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ReferencerRuleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,500 +50,231 @@ namespace CDP4JsonSerializer public class ReferencerRuleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ReferencerRule referencerRule) - { - throw new ArgumentException("The thing shall be a ReferencerRule", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ReferencerRule since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ReferencerRule for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in referencerRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(referencerRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in referencerRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in referencerRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(referencerRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(referencerRule.IsDeprecated); - writer.WritePropertyName("maxReferenced"u8); - writer.WriteNumberValue(referencerRule.MaxReferenced); - writer.WritePropertyName("minReferenced"u8); - writer.WriteNumberValue(referencerRule.MinReferenced); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(referencerRule.Name); - writer.WriteStartArray("referencedCategory"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var referencedCategoryItem in referencerRule.ReferencedCategory.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(referencedCategoryItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("referencingCategory"u8); - writer.WriteStringValue(referencerRule.ReferencingCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(referencerRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(referencerRule.ShortName); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ReferencerRule for Version 1.1.0"); writer.WriteStartArray("alias"u8); - foreach(var aliasItem in referencerRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(aliasItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(referencerRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in referencerRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in referencerRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in referencerRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in referencerRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(referencerRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(referencerRule.IsDeprecated); - writer.WritePropertyName("maxReferenced"u8); - writer.WriteNumberValue(referencerRule.MaxReferenced); - writer.WritePropertyName("minReferenced"u8); - writer.WriteNumberValue(referencerRule.MinReferenced); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(referencerRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(referencerRule.Name); - writer.WriteStartArray("referencedCategory"u8); + writer.WriteStartArray("definition"u8); - foreach(var referencedCategoryItem in referencerRule.ReferencedCategory.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(referencedCategoryItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("referencingCategory"u8); - writer.WriteStringValue(referencerRule.ReferencingCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(referencerRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(referencerRule.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ReferencerRule for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in referencerRule.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(referencerRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in referencerRule.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in referencerRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in referencerRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in referencerRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(referencerRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(referencerRule.IsDeprecated); - writer.WritePropertyName("maxReferenced"u8); - writer.WriteNumberValue(referencerRule.MaxReferenced); - writer.WritePropertyName("minReferenced"u8); - writer.WriteNumberValue(referencerRule.MinReferenced); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(referencerRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(referencerRule.Name); - writer.WriteStartArray("referencedCategory"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var referencedCategoryItem in referencerRule.ReferencedCategory.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(referencedCategoryItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("referencingCategory"u8); - writer.WriteStringValue(referencerRule.ReferencingCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(referencerRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(referencerRule.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(referencerRule.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ReferencerRule for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(referencerRule.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(referencerRule.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in referencerRule.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(referencerRule.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in referencerRule.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in referencerRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in referencerRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in referencerRule.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(referencerRule.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(referencerRule.IsDeprecated); - writer.WritePropertyName("maxReferenced"u8); - writer.WriteNumberValue(referencerRule.MaxReferenced); - writer.WritePropertyName("minReferenced"u8); - writer.WriteNumberValue(referencerRule.MinReferenced); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(referencerRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(referencerRule.Name); - writer.WriteStartArray("referencedCategory"u8); - - foreach(var referencedCategoryItem in referencerRule.ReferencedCategory.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(referencedCategoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("referencingCategory"u8); - writer.WriteStringValue(referencerRule.ReferencingCategory); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(referencerRule.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(referencerRule.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(referencerRule.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - writer.WriteNullValue(); - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { return; } @@ -562,7 +292,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "maxreferenced": - if(!AllowedVersionsPerProperty["maxReferenced"].Contains(requestedVersion)) + var allowedVersionsForMaxReferenced = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMaxReferenced.Contains(requestedVersion)) { return; } @@ -580,7 +318,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "minreferenced": - if(!AllowedVersionsPerProperty["minReferenced"].Contains(requestedVersion)) + var allowedVersionsForMinReferenced = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForMinReferenced.Contains(requestedVersion)) { return; } @@ -598,7 +344,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -616,7 +369,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -634,7 +395,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "referencedcategory": - if(!AllowedVersionsPerProperty["referencedCategory"].Contains(requestedVersion)) + var allowedVersionsForReferencedCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReferencedCategory.Contains(requestedVersion)) { return; } @@ -652,7 +421,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "referencingcategory": - if(!AllowedVersionsPerProperty["referencingCategory"].Contains(requestedVersion)) + var allowedVersionsForReferencingCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReferencingCategory.Contains(requestedVersion)) { return; } @@ -670,7 +447,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -688,7 +473,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -706,7 +499,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -729,29 +528,317 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "maxReferenced", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "minReferenced", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "referencedCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "referencingCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not ReferencerRule referencerRule) + { + throw new ArgumentException("The thing shall be a ReferencerRule", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ReferencerRule since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ReferencerRule for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in referencerRule.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(referencerRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in referencerRule.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in referencerRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(referencerRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(referencerRule.IsDeprecated); + writer.WritePropertyName("maxReferenced"u8); + writer.WriteNumberValue(referencerRule.MaxReferenced); + writer.WritePropertyName("minReferenced"u8); + writer.WriteNumberValue(referencerRule.MinReferenced); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(referencerRule.Name); + writer.WriteStartArray("referencedCategory"u8); + + foreach(var referencedCategoryItem in referencerRule.ReferencedCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referencedCategoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("referencingCategory"u8); + writer.WriteStringValue(referencerRule.ReferencingCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(referencerRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(referencerRule.ShortName); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ReferencerRule for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in referencerRule.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(referencerRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in referencerRule.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in referencerRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in referencerRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in referencerRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(referencerRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(referencerRule.IsDeprecated); + writer.WritePropertyName("maxReferenced"u8); + writer.WriteNumberValue(referencerRule.MaxReferenced); + writer.WritePropertyName("minReferenced"u8); + writer.WriteNumberValue(referencerRule.MinReferenced); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(referencerRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(referencerRule.Name); + writer.WriteStartArray("referencedCategory"u8); + + foreach(var referencedCategoryItem in referencerRule.ReferencedCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referencedCategoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("referencingCategory"u8); + writer.WriteStringValue(referencerRule.ReferencingCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(referencerRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(referencerRule.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ReferencerRule for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in referencerRule.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(referencerRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in referencerRule.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in referencerRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in referencerRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in referencerRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(referencerRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(referencerRule.IsDeprecated); + writer.WritePropertyName("maxReferenced"u8); + writer.WriteNumberValue(referencerRule.MaxReferenced); + writer.WritePropertyName("minReferenced"u8); + writer.WriteNumberValue(referencerRule.MinReferenced); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(referencerRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(referencerRule.Name); + writer.WriteStartArray("referencedCategory"u8); + + foreach(var referencedCategoryItem in referencerRule.ReferencedCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referencedCategoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("referencingCategory"u8); + writer.WriteStringValue(referencerRule.ReferencingCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(referencerRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(referencerRule.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(referencerRule.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ReferencerRule for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(referencerRule.Actor.HasValue) + { + writer.WriteStringValue(referencerRule.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in referencerRule.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(referencerRule.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in referencerRule.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in referencerRule.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in referencerRule.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in referencerRule.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(referencerRule.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(referencerRule.IsDeprecated); + writer.WritePropertyName("maxReferenced"u8); + writer.WriteNumberValue(referencerRule.MaxReferenced); + writer.WritePropertyName("minReferenced"u8); + writer.WriteNumberValue(referencerRule.MinReferenced); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(referencerRule.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(referencerRule.Name); + writer.WriteStartArray("referencedCategory"u8); + + foreach(var referencedCategoryItem in referencerRule.ReferencedCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referencedCategoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("referencingCategory"u8); + writer.WriteStringValue(referencerRule.ReferencingCategory); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(referencerRule.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(referencerRule.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(referencerRule.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/RelationalExpressionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/RelationalExpressionSerializer.cs index dd52a206..c7a9b5bf 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/RelationalExpressionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/RelationalExpressionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,213 +49,6 @@ namespace CDP4JsonSerializer /// public class RelationalExpressionSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not RelationalExpression relationalExpression) - { - throw new ArgumentException("The thing shall be a RelationalExpression", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of RelationalExpression since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing RelationalExpression for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(relationalExpression.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(relationalExpression.Iid); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(relationalExpression.ParameterType); - writer.WritePropertyName("relationalOperator"u8); - writer.WriteStringValue(relationalExpression.RelationalOperator.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(relationalExpression.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(relationalExpression.Scale.HasValue) - { - writer.WriteStringValue(relationalExpression.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteString("value"u8, relationalExpression.Value.ToJsonString()); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing RelationalExpression for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(relationalExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in relationalExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in relationalExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(relationalExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(relationalExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(relationalExpression.ParameterType); - writer.WritePropertyName("relationalOperator"u8); - writer.WriteStringValue(relationalExpression.RelationalOperator.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(relationalExpression.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(relationalExpression.Scale.HasValue) - { - writer.WriteStringValue(relationalExpression.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteString("value"u8, relationalExpression.Value.ToJsonString()); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing RelationalExpression for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(relationalExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in relationalExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in relationalExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(relationalExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(relationalExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(relationalExpression.ParameterType); - writer.WritePropertyName("relationalOperator"u8); - writer.WriteStringValue(relationalExpression.RelationalOperator.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(relationalExpression.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(relationalExpression.Scale.HasValue) - { - writer.WriteStringValue(relationalExpression.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(relationalExpression.ThingPreference); - writer.WriteString("value"u8, relationalExpression.Value.ToJsonString()); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing RelationalExpression for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(relationalExpression.Actor.HasValue) - { - writer.WriteStringValue(relationalExpression.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(relationalExpression.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in relationalExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in relationalExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(relationalExpression.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(relationalExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(relationalExpression.ParameterType); - writer.WritePropertyName("relationalOperator"u8); - writer.WriteStringValue(relationalExpression.RelationalOperator.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(relationalExpression.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(relationalExpression.Scale.HasValue) - { - writer.WriteStringValue(relationalExpression.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(relationalExpression.ThingPreference); - writer.WriteString("value"u8, relationalExpression.Value.ToJsonString()); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -264,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -272,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -290,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -308,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -326,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -344,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -362,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -380,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + var allowedVersionsForParameterType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterType.Contains(requestedVersion)) { return; } @@ -398,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "relationaloperator": - if(!AllowedVersionsPerProperty["relationalOperator"].Contains(requestedVersion)) + var allowedVersionsForRelationalOperator = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRelationalOperator.Contains(requestedVersion)) { return; } @@ -416,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -434,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "scale": - if(!AllowedVersionsPerProperty["scale"].Contains(requestedVersion)) + var allowedVersionsForScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForScale.Contains(requestedVersion)) { return; } @@ -452,7 +317,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -470,7 +341,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "value": - if(!AllowedVersionsPerProperty["value"].Contains(requestedVersion)) + var allowedVersionsForValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValue.Contains(requestedVersion)) { return; } @@ -483,23 +362,205 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "relationalOperator", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "scale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "value", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not RelationalExpression relationalExpression) + { + throw new ArgumentException("The thing shall be a RelationalExpression", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of RelationalExpression since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing RelationalExpression for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(relationalExpression.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(relationalExpression.Iid); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(relationalExpression.ParameterType); + writer.WritePropertyName("relationalOperator"u8); + writer.WriteStringValue(relationalExpression.RelationalOperator.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(relationalExpression.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(relationalExpression.Scale.HasValue) + { + writer.WriteStringValue(relationalExpression.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteString("value"u8, relationalExpression.Value.ToJsonString()); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing RelationalExpression for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(relationalExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in relationalExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in relationalExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(relationalExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(relationalExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(relationalExpression.ParameterType); + writer.WritePropertyName("relationalOperator"u8); + writer.WriteStringValue(relationalExpression.RelationalOperator.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(relationalExpression.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(relationalExpression.Scale.HasValue) + { + writer.WriteStringValue(relationalExpression.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteString("value"u8, relationalExpression.Value.ToJsonString()); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing RelationalExpression for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(relationalExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in relationalExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in relationalExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(relationalExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(relationalExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(relationalExpression.ParameterType); + writer.WritePropertyName("relationalOperator"u8); + writer.WriteStringValue(relationalExpression.RelationalOperator.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(relationalExpression.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(relationalExpression.Scale.HasValue) + { + writer.WriteStringValue(relationalExpression.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(relationalExpression.ThingPreference); + writer.WriteString("value"u8, relationalExpression.Value.ToJsonString()); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing RelationalExpression for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(relationalExpression.Actor.HasValue) + { + writer.WriteStringValue(relationalExpression.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(relationalExpression.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in relationalExpression.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in relationalExpression.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(relationalExpression.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(relationalExpression.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(relationalExpression.ParameterType); + writer.WritePropertyName("relationalOperator"u8); + writer.WriteStringValue(relationalExpression.RelationalOperator.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(relationalExpression.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(relationalExpression.Scale.HasValue) + { + writer.WriteStringValue(relationalExpression.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(relationalExpression.ThingPreference); + writer.WriteString("value"u8, relationalExpression.Value.ToJsonString()); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/RelationshipParameterValueSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/RelationshipParameterValueSerializer.cs index 751c35b7..a7653761 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/RelationshipParameterValueSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/RelationshipParameterValueSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,182 +49,6 @@ namespace CDP4JsonSerializer /// public class RelationshipParameterValueSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not RelationshipParameterValue relationshipParameterValue) - { - throw new ArgumentException("The thing shall be a RelationshipParameterValue", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of RelationshipParameterValue since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing RelationshipParameterValue for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(relationshipParameterValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in relationshipParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in relationshipParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(relationshipParameterValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(relationshipParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(relationshipParameterValue.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(relationshipParameterValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(relationshipParameterValue.Scale.HasValue) - { - writer.WriteStringValue(relationshipParameterValue.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteString("value"u8, relationshipParameterValue.Value.ToJsonString()); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing RelationshipParameterValue for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(relationshipParameterValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in relationshipParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in relationshipParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(relationshipParameterValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(relationshipParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(relationshipParameterValue.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(relationshipParameterValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(relationshipParameterValue.Scale.HasValue) - { - writer.WriteStringValue(relationshipParameterValue.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(relationshipParameterValue.ThingPreference); - writer.WriteString("value"u8, relationshipParameterValue.Value.ToJsonString()); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing RelationshipParameterValue for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(relationshipParameterValue.Actor.HasValue) - { - writer.WriteStringValue(relationshipParameterValue.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(relationshipParameterValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in relationshipParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in relationshipParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(relationshipParameterValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(relationshipParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(relationshipParameterValue.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(relationshipParameterValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(relationshipParameterValue.Scale.HasValue) - { - writer.WriteStringValue(relationshipParameterValue.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(relationshipParameterValue.ThingPreference); - writer.WriteString("value"u8, relationshipParameterValue.Value.ToJsonString()); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -233,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -241,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -259,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -277,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -295,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -313,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -331,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -349,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + var allowedVersionsForParameterType = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterType.Contains(requestedVersion)) { return; } @@ -367,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -385,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "scale": - if(!AllowedVersionsPerProperty["scale"].Contains(requestedVersion)) + var allowedVersionsForScale = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForScale.Contains(requestedVersion)) { return; } @@ -403,7 +286,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -421,7 +310,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "value": - if(!AllowedVersionsPerProperty["value"].Contains(requestedVersion)) + var allowedVersionsForValue = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValue.Contains(requestedVersion)) { return; } @@ -434,22 +330,174 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "scale", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "value", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not RelationshipParameterValue relationshipParameterValue) + { + throw new ArgumentException("The thing shall be a RelationshipParameterValue", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of RelationshipParameterValue since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing RelationshipParameterValue for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(relationshipParameterValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in relationshipParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in relationshipParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(relationshipParameterValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(relationshipParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(relationshipParameterValue.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(relationshipParameterValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(relationshipParameterValue.Scale.HasValue) + { + writer.WriteStringValue(relationshipParameterValue.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteString("value"u8, relationshipParameterValue.Value.ToJsonString()); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing RelationshipParameterValue for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(relationshipParameterValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in relationshipParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in relationshipParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(relationshipParameterValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(relationshipParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(relationshipParameterValue.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(relationshipParameterValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(relationshipParameterValue.Scale.HasValue) + { + writer.WriteStringValue(relationshipParameterValue.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(relationshipParameterValue.ThingPreference); + writer.WriteString("value"u8, relationshipParameterValue.Value.ToJsonString()); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing RelationshipParameterValue for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(relationshipParameterValue.Actor.HasValue) + { + writer.WriteStringValue(relationshipParameterValue.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(relationshipParameterValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in relationshipParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in relationshipParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(relationshipParameterValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(relationshipParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(relationshipParameterValue.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(relationshipParameterValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(relationshipParameterValue.Scale.HasValue) + { + writer.WriteStringValue(relationshipParameterValue.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(relationshipParameterValue.ThingPreference); + writer.WriteString("value"u8, relationshipParameterValue.Value.ToJsonString()); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/RequestForDeviationSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/RequestForDeviationSerializer.cs index 8aabd337..c9ae82ee 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/RequestForDeviationSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/RequestForDeviationSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,418 +50,305 @@ namespace CDP4JsonSerializer public class RequestForDeviationSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not RequestForDeviation requestForDeviation) - { - throw new ArgumentException("The thing shall be a RequestForDeviation", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of RequestForDeviation since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing RequestForDeviation for Version 1.1.0"); - writer.WriteStartArray("approvedBy"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var approvedByItem in requestForDeviation.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(requestForDeviation.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in requestForDeviation.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(requestForDeviation.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requestForDeviation.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(requestForDeviation.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(requestForDeviation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "approvedby": + var allowedVersionsForApprovedBy = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in requestForDeviation.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForApprovedBy.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("approvedBy"u8); - foreach(var excludedDomainItem in requestForDeviation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListApprovedBy) { - writer.WriteStringValue(excludedDomainItem); + foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(approvedByItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "author": + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in requestForDeviation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("author"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requestForDeviation.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(requestForDeviation.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requestForDeviation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requestForDeviation.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(requestForDeviation.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(requestForDeviation.PrimaryAnnotatedThing.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var relatedThingItem in requestForDeviation.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(relatedThingItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requestForDeviation.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requestForDeviation.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + writer.WriteStartArray("category"u8); - foreach(var sourceAnnotationItem in requestForDeviation.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(sourceAnnotationItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(requestForDeviation.Status.ToString()); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(requestForDeviation.Title); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing RequestForDeviation for Version 1.2.0"); - writer.WriteStartArray("approvedBy"u8); + case "classification": + var allowedVersionsForClassification = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in requestForDeviation.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassification.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(requestForDeviation.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in requestForDeviation.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(requestForDeviation.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requestForDeviation.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(requestForDeviation.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(requestForDeviation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in requestForDeviation.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requestForDeviation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "content": + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in requestForDeviation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContent.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("content"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requestForDeviation.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(requestForDeviation.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requestForDeviation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requestForDeviation.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(requestForDeviation.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(requestForDeviation.PrimaryAnnotatedThing.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in requestForDeviation.RelatedThing.OrderBy(x => x, this.GuidComparer)) + break; + case "createdon": + var allowedVersionsForCreatedOn = new List { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requestForDeviation.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requestForDeviation.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var sourceAnnotationItem in requestForDeviation.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { - writer.WriteStringValue(sourceAnnotationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("createdOn"u8); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(requestForDeviation.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requestForDeviation.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(requestForDeviation.Title); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing RequestForDeviation for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(requestForDeviation.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(requestForDeviation.Actor.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("approvedBy"u8); + break; + case "discussion": + var allowedVersionsForDiscussion = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in requestForDeviation.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDiscussion.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(requestForDeviation.Author); - writer.WriteStartArray("category"u8); + writer.WriteStartArray("discussion"u8); - foreach(var categoryItem in requestForDeviation.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDiscussion) { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(requestForDeviation.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requestForDeviation.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(requestForDeviation.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(requestForDeviation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in requestForDeviation.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); + foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requestForDeviation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in requestForDeviation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requestForDeviation.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(requestForDeviation.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requestForDeviation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requestForDeviation.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(requestForDeviation.PrimaryAnnotatedThing.HasValue) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(requestForDeviation.PrimaryAnnotatedThing.Value); - } - else - { - writer.WriteNullValue(); + return; } - writer.WriteStartArray("relatedThing"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var relatedThingItem in requestForDeviation.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(relatedThingItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requestForDeviation.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requestForDeviation.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); - - foreach(var sourceAnnotationItem in requestForDeviation.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sourceAnnotationItem); - } - writer.WriteEndArray(); - - writer.WritePropertyName("status"u8); - writer.WriteStringValue(requestForDeviation.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requestForDeviation.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(requestForDeviation.Title); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + case "excludedperson": + var allowedVersionsForExcludedPerson = new List { - writer.WriteNullValue(); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - break; - case "approvedby": - if(!AllowedVersionsPerProperty["approvedBy"].Contains(requestedVersion)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } - writer.WriteStartArray("approvedBy"u8); + writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListApprovedBy) + if(value is IEnumerable objectListExcludedPerson) { - foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(approvedByItem); + writer.WriteStringValue(excludedPersonItem); } } writer.WriteEndArray(); break; - case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } - writer.WritePropertyName("author"u8); + writer.WritePropertyName("iid"u8); if(value != null) { @@ -474,35 +360,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "languagecode": + var allowedVersionsForLanguageCode = new List { - return; - } - - writer.WriteStartArray("category"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListCategory) - { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - } - - writer.WriteEndArray(); - break; - case "classification": - if(!AllowedVersionsPerProperty["classification"].Contains(requestedVersion)) + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classification"u8); + writer.WritePropertyName("languageCode"u8); if(value != null) { - writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -510,17 +385,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -528,17 +410,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + case "owner": + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } - writer.WritePropertyName("content"u8); + writer.WritePropertyName("owner"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue((Guid)value); } else { @@ -546,17 +435,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + case "primaryannotatedthing": + var allowedVersionsForPrimaryAnnotatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPrimaryAnnotatedThing.Contains(requestedVersion)) { return; } - writer.WritePropertyName("createdOn"u8); + writer.WritePropertyName("primaryAnnotatedThing"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((Guid)value); } else { @@ -564,71 +460,124 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "discussion": - if(!AllowedVersionsPerProperty["discussion"].Contains(requestedVersion)) + case "relatedthing": + var allowedVersionsForRelatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRelatedThing.Contains(requestedVersion)) { return; } - writer.WriteStartArray("discussion"u8); + writer.WriteStartArray("relatedThing"u8); - if(value is IEnumerable objectListDiscussion) + if(value is IEnumerable objectListRelatedThing) { - foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(discussionItem); + writer.WriteStringValue(relatedThingItem); } } writer.WriteEndArray(); break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } - if(value is IEnumerable objectListExcludedDomain) + break; + case "shortname": + var allowedVersionsForShortName = new List { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; } + + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "sourceannotation": + var allowedVersionsForSourceAnnotation = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSourceAnnotation.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("sourceAnnotation"u8); - if(value is IEnumerable objectListExcludedPerson) + if(value is IEnumerable objectListSourceAnnotation) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(sourceAnnotationItem); } } writer.WriteEndArray(); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + case "status": + var allowedVersionsForStatus = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStatus.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("status"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); } else { @@ -636,13 +585,19 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("languageCode"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { @@ -654,17 +609,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "title": + var allowedVersionsForTitle = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTitle.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); + writer.WritePropertyName("title"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((string)value); } else { @@ -672,202 +634,345 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the RequestForDeviation"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not RequestForDeviation requestForDeviation) + { + throw new ArgumentException("The thing shall be a RequestForDeviation", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of RequestForDeviation since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing RequestForDeviation for Version 1.1.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in requestForDeviation.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("owner"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(requestForDeviation.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requestForDeviation.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(requestForDeviation.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requestForDeviation.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(requestForDeviation.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(requestForDeviation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in requestForDeviation.Discussion.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(discussionItem); } - break; - case "primaryannotatedthing": - if(!AllowedVersionsPerProperty["primaryAnnotatedThing"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requestForDeviation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requestForDeviation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requestForDeviation.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(requestForDeviation.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requestForDeviation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requestForDeviation.Owner); writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(value != null) + + if(requestForDeviation.PrimaryAnnotatedThing.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(requestForDeviation.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "relatedthing": - if(!AllowedVersionsPerProperty["relatedThing"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in requestForDeviation.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); } - writer.WriteStartArray("relatedThing"u8); + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requestForDeviation.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requestForDeviation.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); - if(value is IEnumerable objectListRelatedThing) + foreach(var sourceAnnotationItem in requestForDeviation.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } + writer.WriteStringValue(sourceAnnotationItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(requestForDeviation.Status.ToString()); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(requestForDeviation.Title); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing RequestForDeviation for Version 1.2.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in requestForDeviation.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(requestForDeviation.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requestForDeviation.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(requestForDeviation.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requestForDeviation.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(requestForDeviation.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(requestForDeviation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in requestForDeviation.Discussion.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(discussionItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requestForDeviation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requestForDeviation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requestForDeviation.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(requestForDeviation.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requestForDeviation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requestForDeviation.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(requestForDeviation.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(requestForDeviation.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "sourceannotation": - if(!AllowedVersionsPerProperty["sourceAnnotation"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in requestForDeviation.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requestForDeviation.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requestForDeviation.ShortName); writer.WriteStartArray("sourceAnnotation"u8); - if(value is IEnumerable objectListSourceAnnotation) + foreach(var sourceAnnotationItem in requestForDeviation.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sourceAnnotationItem); - } + writer.WriteStringValue(sourceAnnotationItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(requestForDeviation.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(requestForDeviation.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(requestForDeviation.Title); break; - case "status": - if(!AllowedVersionsPerProperty["status"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing RequestForDeviation for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("status"u8); - - if(value != null) + if(requestForDeviation.Actor.HasValue) { - writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); + writer.WriteStringValue(requestForDeviation.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in requestForDeviation.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(requestForDeviation.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requestForDeviation.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(requestForDeviation.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requestForDeviation.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(requestForDeviation.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(requestForDeviation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in requestForDeviation.Discussion.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(discussionItem); } - break; - case "title": - if(!AllowedVersionsPerProperty["title"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requestForDeviation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("title"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requestForDeviation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requestForDeviation.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(requestForDeviation.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requestForDeviation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requestForDeviation.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(requestForDeviation.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(requestForDeviation.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in requestForDeviation.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requestForDeviation.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requestForDeviation.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in requestForDeviation.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(requestForDeviation.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(requestForDeviation.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(requestForDeviation.Title); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the RequestForDeviation"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "approvedBy", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classification", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "discussion", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "primaryAnnotatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "relatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "sourceAnnotation", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "status", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "title", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/RequestForWaiverSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/RequestForWaiverSerializer.cs index e083024a..322fed87 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/RequestForWaiverSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/RequestForWaiverSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,418 +50,305 @@ namespace CDP4JsonSerializer public class RequestForWaiverSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not RequestForWaiver requestForWaiver) - { - throw new ArgumentException("The thing shall be a RequestForWaiver", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of RequestForWaiver since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing RequestForWaiver for Version 1.1.0"); - writer.WriteStartArray("approvedBy"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var approvedByItem in requestForWaiver.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(requestForWaiver.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in requestForWaiver.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(requestForWaiver.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requestForWaiver.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(requestForWaiver.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(requestForWaiver.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "approvedby": + var allowedVersionsForApprovedBy = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in requestForWaiver.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForApprovedBy.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("approvedBy"u8); - foreach(var excludedDomainItem in requestForWaiver.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListApprovedBy) { - writer.WriteStringValue(excludedDomainItem); + foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(approvedByItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "author": + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in requestForWaiver.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("author"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requestForWaiver.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(requestForWaiver.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requestForWaiver.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requestForWaiver.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(requestForWaiver.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(requestForWaiver.PrimaryAnnotatedThing.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var relatedThingItem in requestForWaiver.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(relatedThingItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requestForWaiver.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requestForWaiver.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + writer.WriteStartArray("category"u8); - foreach(var sourceAnnotationItem in requestForWaiver.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(sourceAnnotationItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(requestForWaiver.Status.ToString()); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(requestForWaiver.Title); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing RequestForWaiver for Version 1.2.0"); - writer.WriteStartArray("approvedBy"u8); + case "classification": + var allowedVersionsForClassification = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in requestForWaiver.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassification.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(requestForWaiver.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in requestForWaiver.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(requestForWaiver.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requestForWaiver.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(requestForWaiver.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(requestForWaiver.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in requestForWaiver.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requestForWaiver.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "content": + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in requestForWaiver.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContent.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("content"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requestForWaiver.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(requestForWaiver.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requestForWaiver.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requestForWaiver.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(requestForWaiver.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(requestForWaiver.PrimaryAnnotatedThing.Value); + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in requestForWaiver.RelatedThing.OrderBy(x => x, this.GuidComparer)) + break; + case "createdon": + var allowedVersionsForCreatedOn = new List { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requestForWaiver.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requestForWaiver.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var sourceAnnotationItem in requestForWaiver.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { - writer.WriteStringValue(sourceAnnotationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("createdOn"u8); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(requestForWaiver.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requestForWaiver.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(requestForWaiver.Title); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing RequestForWaiver for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(requestForWaiver.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(requestForWaiver.Actor.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("approvedBy"u8); + break; + case "discussion": + var allowedVersionsForDiscussion = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in requestForWaiver.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDiscussion.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(requestForWaiver.Author); - writer.WriteStartArray("category"u8); + writer.WriteStartArray("discussion"u8); - foreach(var categoryItem in requestForWaiver.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDiscussion) { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(requestForWaiver.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requestForWaiver.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(requestForWaiver.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(requestForWaiver.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in requestForWaiver.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); + foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requestForWaiver.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in requestForWaiver.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requestForWaiver.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(requestForWaiver.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requestForWaiver.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requestForWaiver.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(requestForWaiver.PrimaryAnnotatedThing.HasValue) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(requestForWaiver.PrimaryAnnotatedThing.Value); - } - else - { - writer.WriteNullValue(); + return; } - writer.WriteStartArray("relatedThing"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var relatedThingItem in requestForWaiver.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(relatedThingItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requestForWaiver.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requestForWaiver.ShortName); - writer.WriteStartArray("sourceAnnotation"u8); - - foreach(var sourceAnnotationItem in requestForWaiver.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sourceAnnotationItem); - } - writer.WriteEndArray(); - - writer.WritePropertyName("status"u8); - writer.WriteStringValue(requestForWaiver.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requestForWaiver.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(requestForWaiver.Title); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + case "excludedperson": + var allowedVersionsForExcludedPerson = new List { - writer.WriteNullValue(); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - break; - case "approvedby": - if(!AllowedVersionsPerProperty["approvedBy"].Contains(requestedVersion)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } - writer.WriteStartArray("approvedBy"u8); + writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListApprovedBy) + if(value is IEnumerable objectListExcludedPerson) { - foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(approvedByItem); + writer.WriteStringValue(excludedPersonItem); } } writer.WriteEndArray(); break; - case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } - writer.WritePropertyName("author"u8); + writer.WritePropertyName("iid"u8); if(value != null) { @@ -474,35 +360,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "languagecode": + var allowedVersionsForLanguageCode = new List { - return; - } - - writer.WriteStartArray("category"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListCategory) - { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - } - - writer.WriteEndArray(); - break; - case "classification": - if(!AllowedVersionsPerProperty["classification"].Contains(requestedVersion)) + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classification"u8); + writer.WritePropertyName("languageCode"u8); if(value != null) { - writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -510,17 +385,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -528,17 +410,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + case "owner": + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } - writer.WritePropertyName("content"u8); + writer.WritePropertyName("owner"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue((Guid)value); } else { @@ -546,17 +435,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + case "primaryannotatedthing": + var allowedVersionsForPrimaryAnnotatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPrimaryAnnotatedThing.Contains(requestedVersion)) { return; } - writer.WritePropertyName("createdOn"u8); + writer.WritePropertyName("primaryAnnotatedThing"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((Guid)value); } else { @@ -564,71 +460,124 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "discussion": - if(!AllowedVersionsPerProperty["discussion"].Contains(requestedVersion)) + case "relatedthing": + var allowedVersionsForRelatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRelatedThing.Contains(requestedVersion)) { return; } - writer.WriteStartArray("discussion"u8); + writer.WriteStartArray("relatedThing"u8); - if(value is IEnumerable objectListDiscussion) + if(value is IEnumerable objectListRelatedThing) { - foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(discussionItem); + writer.WriteStringValue(relatedThingItem); } } writer.WriteEndArray(); break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } - if(value is IEnumerable objectListExcludedDomain) + break; + case "shortname": + var allowedVersionsForShortName = new List { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; } + + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "sourceannotation": + var allowedVersionsForSourceAnnotation = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSourceAnnotation.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("sourceAnnotation"u8); - if(value is IEnumerable objectListExcludedPerson) + if(value is IEnumerable objectListSourceAnnotation) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(sourceAnnotationItem); } } writer.WriteEndArray(); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + case "status": + var allowedVersionsForStatus = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStatus.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("status"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); } else { @@ -636,13 +585,19 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("languageCode"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { @@ -654,17 +609,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "title": + var allowedVersionsForTitle = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTitle.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); + writer.WritePropertyName("title"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((string)value); } else { @@ -672,202 +634,345 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the RequestForWaiver"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not RequestForWaiver requestForWaiver) + { + throw new ArgumentException("The thing shall be a RequestForWaiver", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of RequestForWaiver since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing RequestForWaiver for Version 1.1.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in requestForWaiver.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("owner"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(requestForWaiver.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requestForWaiver.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(requestForWaiver.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requestForWaiver.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(requestForWaiver.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(requestForWaiver.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in requestForWaiver.Discussion.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(discussionItem); } - break; - case "primaryannotatedthing": - if(!AllowedVersionsPerProperty["primaryAnnotatedThing"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requestForWaiver.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requestForWaiver.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requestForWaiver.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(requestForWaiver.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requestForWaiver.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requestForWaiver.Owner); writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(value != null) + + if(requestForWaiver.PrimaryAnnotatedThing.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(requestForWaiver.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "relatedthing": - if(!AllowedVersionsPerProperty["relatedThing"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in requestForWaiver.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); } - writer.WriteStartArray("relatedThing"u8); + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requestForWaiver.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requestForWaiver.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); - if(value is IEnumerable objectListRelatedThing) + foreach(var sourceAnnotationItem in requestForWaiver.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } + writer.WriteStringValue(sourceAnnotationItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(requestForWaiver.Status.ToString()); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(requestForWaiver.Title); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing RequestForWaiver for Version 1.2.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in requestForWaiver.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(requestForWaiver.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requestForWaiver.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(requestForWaiver.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requestForWaiver.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(requestForWaiver.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(requestForWaiver.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in requestForWaiver.Discussion.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(discussionItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requestForWaiver.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requestForWaiver.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requestForWaiver.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(requestForWaiver.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requestForWaiver.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requestForWaiver.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(requestForWaiver.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(requestForWaiver.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "sourceannotation": - if(!AllowedVersionsPerProperty["sourceAnnotation"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in requestForWaiver.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requestForWaiver.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requestForWaiver.ShortName); writer.WriteStartArray("sourceAnnotation"u8); - if(value is IEnumerable objectListSourceAnnotation) + foreach(var sourceAnnotationItem in requestForWaiver.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sourceAnnotationItem); - } + writer.WriteStringValue(sourceAnnotationItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(requestForWaiver.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(requestForWaiver.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(requestForWaiver.Title); break; - case "status": - if(!AllowedVersionsPerProperty["status"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing RequestForWaiver for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("status"u8); - - if(value != null) + if(requestForWaiver.Actor.HasValue) { - writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); + writer.WriteStringValue(requestForWaiver.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in requestForWaiver.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(requestForWaiver.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requestForWaiver.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(requestForWaiver.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requestForWaiver.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(requestForWaiver.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(requestForWaiver.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in requestForWaiver.Discussion.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(discussionItem); } - break; - case "title": - if(!AllowedVersionsPerProperty["title"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requestForWaiver.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("title"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requestForWaiver.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requestForWaiver.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(requestForWaiver.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requestForWaiver.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requestForWaiver.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(requestForWaiver.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(requestForWaiver.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in requestForWaiver.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requestForWaiver.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requestForWaiver.ShortName); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in requestForWaiver.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(requestForWaiver.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(requestForWaiver.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(requestForWaiver.Title); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the RequestForWaiver"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "approvedBy", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classification", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "discussion", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "primaryAnnotatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "relatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "sourceAnnotation", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "status", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "title", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementSerializer.cs index 5edc2e7d..489a7dab 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,461 +50,365 @@ namespace CDP4JsonSerializer public class RequirementSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not Requirement requirement) - { - throw new ArgumentException("The thing shall be a Requirement", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Requirement since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Requirement for Version 1.0.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in requirement.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in requirement.Category.OrderBy(x => x, this.GuidComparer)) + case "actor": + var allowedVersionsForActor = new List { - writer.WriteStringValue(categoryItem); - } + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirement.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in requirement.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("group"u8); - - if(requirement.Group.HasValue) + if(value != null) { - writer.WriteStringValue(requirement.Group.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in requirement.HyperLink.OrderBy(x => x, this.GuidComparer)) + break; + case "alias": + var allowedVersionsForAlias = new List { - writer.WriteStringValue(hyperLinkItem); - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirement.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(requirement.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirement.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirement.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in requirement.ParameterValue.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(parameterValueItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("parametricConstraint"u8); + writer.WriteStartArray("alias"u8); - foreach(var parametricConstraintItem in requirement.ParametricConstraint.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteOrderedItem(parametricConstraintItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirement.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirement.ShortName); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Requirement for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in requirement.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in requirement.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirement.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in requirement.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requirement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + case "classkind": + var allowedVersionsForClassKind = new List { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in requirement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("group"u8); - - if(requirement.Group.HasValue) + if(value != null) { - writer.WriteStringValue(requirement.Group.Value); + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in requirement.HyperLink.OrderBy(x => x, this.GuidComparer)) + break; + case "definition": + var allowedVersionsForDefinition = new List { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirement.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(requirement.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirement.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirement.Owner); - writer.WriteStartArray("parameterValue"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var parameterValueItem in requirement.ParameterValue.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(parameterValueItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("parametricConstraint"u8); + writer.WriteStartArray("definition"u8); - foreach(var parametricConstraintItem in requirement.ParametricConstraint.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteOrderedItem(parametricConstraintItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirement.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirement.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Requirement for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in requirement.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in requirement.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirement.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in requirement.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in requirement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "group": + var allowedVersionsForGroup = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in requirement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForGroup.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("group"u8); - - if(requirement.Group.HasValue) + + if(value != null) { - writer.WriteStringValue(requirement.Group.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("hyperLink"u8); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in requirement.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirement.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(requirement.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirement.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirement.Owner); - writer.WriteStartArray("parameterValue"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var parameterValueItem in requirement.ParameterValue.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(parameterValueItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("parametricConstraint"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var parametricConstraintItem in requirement.ParametricConstraint.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteOrderedItem(parametricConstraintItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirement.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirement.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requirement.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Requirement for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(requirement.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(requirement.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in requirement.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in requirement.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirement.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in requirement.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requirement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in requirement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WritePropertyName("group"u8); - - if(requirement.Group.HasValue) + if(value != null) { - writer.WriteStringValue(requirement.Group.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("hyperLink"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in requirement.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirement.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(requirement.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirement.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirement.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in requirement.ParameterValue.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(parameterValueItem); + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("parametricConstraint"u8); - - foreach(var parametricConstraintItem in requirement.ParametricConstraint.OrderBy(x => x, this.OrderedItemComparer)) + else { - writer.WriteOrderedItem(parametricConstraintItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirement.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirement.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requirement.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "owner": + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("owner"u8); if(value != null) { @@ -517,53 +420,77 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "parametervalue": + var allowedVersionsForParameterValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterValue.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("parameterValue"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListParameterValue) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var parameterValueItem in objectListParameterValue.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteStringValue(parameterValueItem); } } writer.WriteEndArray(); break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "parametricconstraint": + var allowedVersionsForParametricConstraint = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParametricConstraint.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("parametricConstraint"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListParametricConstraint) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var parametricConstraintItem in objectListParametricConstraint.OfType().OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteOrderedItem(parametricConstraintItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -571,71 +498,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List { - return; - } - - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "group": - if(!AllowedVersionsPerProperty["group"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("group"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -643,234 +548,415 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) - { - return; - } + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the Requirement"); + } + } - writer.WriteStartArray("hyperLink"u8); + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not Requirement requirement) + { + throw new ArgumentException("The thing shall be a Requirement", nameof(thing)); + } - if(value is IEnumerable objectListHyperLink) + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Requirement since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Requirement for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirement.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requirement.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirement.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirement.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("group"u8); + + if(requirement.Group.HasValue) + { + writer.WriteStringValue(requirement.Group.Value); } else { writer.WriteNullValue(); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in requirement.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirement.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteBooleanValue(requirement.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(requirement.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requirement.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in requirement.ParameterValue.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(parameterValueItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("parametricConstraint"u8); + + foreach(var parametricConstraintItem in requirement.ParametricConstraint.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(parametricConstraintItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirement.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requirement.ShortName); break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Requirement for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirement.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requirement.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirement.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirement.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requirement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requirement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("group"u8); + + if(requirement.Group.HasValue) + { + writer.WriteStringValue(requirement.Group.Value); } else { writer.WriteNullValue(); } - break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in requirement.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirement.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(requirement.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(requirement.Name); writer.WritePropertyName("owner"u8); - - if(value != null) + writer.WriteStringValue(requirement.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in requirement.ParameterValue.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(parameterValueItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("parametricConstraint"u8); + + foreach(var parametricConstraintItem in requirement.ParametricConstraint.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(parametricConstraintItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirement.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requirement.ShortName); break; - case "parametervalue": - if(!AllowedVersionsPerProperty["parameterValue"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Requirement for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirement.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("parameterValue"u8); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListParameterValue) + foreach(var categoryItem in requirement.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var parameterValueItem in objectListParameterValue.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterValueItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "parametricconstraint": - if(!AllowedVersionsPerProperty["parametricConstraint"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirement.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirement.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WriteStartArray("parametricConstraint"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListParametricConstraint) + foreach(var excludedDomainItem in requirement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var parametricConstraintItem in objectListParametricConstraint.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(parametricConstraintItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requirement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("group"u8); + + if(requirement.Group.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(requirement.Group.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in requirement.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirement.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(requirement.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(requirement.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requirement.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in requirement.ParameterValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterValueItem); } + writer.WriteEndArray(); + writer.WriteStartArray("parametricConstraint"u8); + + foreach(var parametricConstraintItem in requirement.ParametricConstraint.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(parametricConstraintItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirement.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(requirement.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(requirement.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Requirement for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(requirement.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(requirement.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirement.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requirement.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirement.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirement.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requirement.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requirement.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("group"u8); + + if(requirement.Group.HasValue) + { + writer.WriteStringValue(requirement.Group.Value); } else { writer.WriteNullValue(); } + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in requirement.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirement.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(requirement.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirement.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(requirement.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requirement.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in requirement.ParameterValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterValueItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("parametricConstraint"u8); + + foreach(var parametricConstraintItem in requirement.ParametricConstraint.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(parametricConstraintItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirement.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requirement.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(requirement.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the Requirement"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "group", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterValue", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parametricConstraint", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsContainerParameterValueSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsContainerParameterValueSerializer.cs index cd791bb9..21e384c1 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsContainerParameterValueSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsContainerParameterValueSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,182 +49,6 @@ namespace CDP4JsonSerializer /// public class RequirementsContainerParameterValueSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not RequirementsContainerParameterValue requirementsContainerParameterValue) - { - throw new ArgumentException("The thing shall be a RequirementsContainerParameterValue", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of RequirementsContainerParameterValue since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing RequirementsContainerParameterValue for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirementsContainerParameterValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requirementsContainerParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in requirementsContainerParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirementsContainerParameterValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirementsContainerParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(requirementsContainerParameterValue.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirementsContainerParameterValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(requirementsContainerParameterValue.Scale.HasValue) - { - writer.WriteStringValue(requirementsContainerParameterValue.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteString("value"u8, requirementsContainerParameterValue.Value.ToJsonString()); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing RequirementsContainerParameterValue for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirementsContainerParameterValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requirementsContainerParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in requirementsContainerParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirementsContainerParameterValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirementsContainerParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(requirementsContainerParameterValue.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirementsContainerParameterValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(requirementsContainerParameterValue.Scale.HasValue) - { - writer.WriteStringValue(requirementsContainerParameterValue.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requirementsContainerParameterValue.ThingPreference); - writer.WriteString("value"u8, requirementsContainerParameterValue.Value.ToJsonString()); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing RequirementsContainerParameterValue for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(requirementsContainerParameterValue.Actor.HasValue) - { - writer.WriteStringValue(requirementsContainerParameterValue.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirementsContainerParameterValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requirementsContainerParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in requirementsContainerParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirementsContainerParameterValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirementsContainerParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(requirementsContainerParameterValue.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirementsContainerParameterValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(requirementsContainerParameterValue.Scale.HasValue) - { - writer.WriteStringValue(requirementsContainerParameterValue.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requirementsContainerParameterValue.ThingPreference); - writer.WriteString("value"u8, requirementsContainerParameterValue.Value.ToJsonString()); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -233,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -241,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -259,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -277,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -295,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -313,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -331,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -349,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + var allowedVersionsForParameterType = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterType.Contains(requestedVersion)) { return; } @@ -367,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -385,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "scale": - if(!AllowedVersionsPerProperty["scale"].Contains(requestedVersion)) + var allowedVersionsForScale = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForScale.Contains(requestedVersion)) { return; } @@ -403,7 +286,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -421,7 +310,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "value": - if(!AllowedVersionsPerProperty["value"].Contains(requestedVersion)) + var allowedVersionsForValue = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValue.Contains(requestedVersion)) { return; } @@ -434,22 +330,174 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "scale", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "value", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not RequirementsContainerParameterValue requirementsContainerParameterValue) + { + throw new ArgumentException("The thing shall be a RequirementsContainerParameterValue", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of RequirementsContainerParameterValue since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing RequirementsContainerParameterValue for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirementsContainerParameterValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requirementsContainerParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requirementsContainerParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirementsContainerParameterValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirementsContainerParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(requirementsContainerParameterValue.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirementsContainerParameterValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(requirementsContainerParameterValue.Scale.HasValue) + { + writer.WriteStringValue(requirementsContainerParameterValue.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteString("value"u8, requirementsContainerParameterValue.Value.ToJsonString()); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing RequirementsContainerParameterValue for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirementsContainerParameterValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requirementsContainerParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requirementsContainerParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirementsContainerParameterValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirementsContainerParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(requirementsContainerParameterValue.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirementsContainerParameterValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(requirementsContainerParameterValue.Scale.HasValue) + { + writer.WriteStringValue(requirementsContainerParameterValue.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(requirementsContainerParameterValue.ThingPreference); + writer.WriteString("value"u8, requirementsContainerParameterValue.Value.ToJsonString()); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing RequirementsContainerParameterValue for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(requirementsContainerParameterValue.Actor.HasValue) + { + writer.WriteStringValue(requirementsContainerParameterValue.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirementsContainerParameterValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requirementsContainerParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requirementsContainerParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirementsContainerParameterValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirementsContainerParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(requirementsContainerParameterValue.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirementsContainerParameterValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(requirementsContainerParameterValue.Scale.HasValue) + { + writer.WriteStringValue(requirementsContainerParameterValue.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(requirementsContainerParameterValue.ThingPreference); + writer.WriteString("value"u8, requirementsContainerParameterValue.Value.ToJsonString()); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsGroupSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsGroupSerializer.cs index 31cc56d6..496d84ec 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsGroupSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsGroupSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,391 +50,338 @@ namespace CDP4JsonSerializer public class RequirementsGroupSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not RequirementsGroup requirementsGroup) - { - throw new ArgumentException("The thing shall be a RequirementsGroup", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of RequirementsGroup since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing RequirementsGroup for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in requirementsGroup.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirementsGroup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in requirementsGroup.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("group"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var groupItem in requirementsGroup.Group.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(groupItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in requirementsGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirementsGroup.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirementsGroup.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirementsGroup.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirementsGroup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirementsGroup.ShortName); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing RequirementsGroup for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in requirementsGroup.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in requirementsGroup.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirementsGroup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in requirementsGroup.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requirementsGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in requirementsGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("group"u8); + writer.WriteStartArray("definition"u8); - foreach(var groupItem in requirementsGroup.Group.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(groupItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in requirementsGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirementsGroup.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirementsGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirementsGroup.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirementsGroup.Owner); - writer.WriteStartArray("parameterValue"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var parameterValueItem in requirementsGroup.ParameterValue.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(parameterValueItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirementsGroup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirementsGroup.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing RequirementsGroup for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in requirementsGroup.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var categoryItem in requirementsGroup.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(categoryItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirementsGroup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "group": + var allowedVersionsForGroup = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in requirementsGroup.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForGroup.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("group"u8); - foreach(var excludedDomainItem in requirementsGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListGroup) { - writer.WriteStringValue(excludedDomainItem); + foreach(var groupItem in objectListGroup.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(groupItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in requirementsGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("group"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var groupItem in requirementsGroup.Group.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(groupItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in requirementsGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirementsGroup.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirementsGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirementsGroup.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirementsGroup.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in requirementsGroup.ParameterValue.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterValueItem); - } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirementsGroup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirementsGroup.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requirementsGroup.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing RequirementsGroup for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(requirementsGroup.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(requirementsGroup.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in requirementsGroup.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in requirementsGroup.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirementsGroup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in requirementsGroup.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requirementsGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in requirementsGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "name": + var allowedVersionsForName = new List { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("group"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var groupItem in requirementsGroup.Group.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(groupItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in requirementsGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirementsGroup.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirementsGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirementsGroup.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirementsGroup.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in requirementsGroup.ParameterValue.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(parameterValueItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirementsGroup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirementsGroup.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requirementsGroup.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "owner": + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("owner"u8); if(value != null) { @@ -447,53 +393,50 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "parametervalue": + var allowedVersionsForParameterValue = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(!allowedVersionsForParameterValue.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("parameterValue"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListParameterValue) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var parameterValueItem in objectListParameterValue.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(parameterValueItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -501,107 +444,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + if(value != null) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "group": - if(!AllowedVersionsPerProperty["group"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("group"u8); - - if(value is IEnumerable objectListGroup) - { - foreach(var groupItem in objectListGroup.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(groupItem); - } - } - - writer.WriteEndArray(); break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List { - return; - } - - writer.WriteStartArray("hyperLink"u8); + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -609,160 +494,347 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the RequirementsGroup"); + } + } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not RequirementsGroup requirementsGroup) + { + throw new ArgumentException("The thing shall be a RequirementsGroup", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of RequirementsGroup since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing RequirementsGroup for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirementsGroup.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(aliasItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirementsGroup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirementsGroup.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("group"u8); + + foreach(var groupItem in requirementsGroup.Group.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(groupItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in requirementsGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirementsGroup.Iid); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(requirementsGroup.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requirementsGroup.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirementsGroup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requirementsGroup.ShortName); break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing RequirementsGroup for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirementsGroup.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("owner"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requirementsGroup.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirementsGroup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirementsGroup.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "parametervalue": - if(!AllowedVersionsPerProperty["parameterValue"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requirementsGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requirementsGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("group"u8); + + foreach(var groupItem in requirementsGroup.Group.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(groupItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in requirementsGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirementsGroup.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirementsGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(requirementsGroup.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requirementsGroup.Owner); writer.WriteStartArray("parameterValue"u8); - if(value is IEnumerable objectListParameterValue) + foreach(var parameterValueItem in requirementsGroup.ParameterValue.OrderBy(x => x, this.GuidComparer)) { - foreach(var parameterValueItem in objectListParameterValue.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterValueItem); - } + writer.WriteStringValue(parameterValueItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirementsGroup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requirementsGroup.ShortName); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing RequirementsGroup for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirementsGroup.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requirementsGroup.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirementsGroup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirementsGroup.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requirementsGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requirementsGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("group"u8); + + foreach(var groupItem in requirementsGroup.Group.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(groupItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in requirementsGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirementsGroup.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirementsGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(requirementsGroup.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requirementsGroup.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in requirementsGroup.ParameterValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterValueItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirementsGroup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requirementsGroup.ShortName); writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteStringValue(requirementsGroup.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing RequirementsGroup for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(requirementsGroup.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(requirementsGroup.Actor.Value); } else { writer.WriteNullValue(); } + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirementsGroup.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requirementsGroup.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirementsGroup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirementsGroup.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requirementsGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requirementsGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("group"u8); + + foreach(var groupItem in requirementsGroup.Group.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(groupItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in requirementsGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirementsGroup.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirementsGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(requirementsGroup.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requirementsGroup.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in requirementsGroup.ParameterValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterValueItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirementsGroup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requirementsGroup.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(requirementsGroup.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the RequirementsGroup"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "group", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterValue", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsSpecificationSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsSpecificationSerializer.cs index a237a7fb..3f9c5533 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsSpecificationSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/RequirementsSpecificationSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,435 +50,364 @@ namespace CDP4JsonSerializer public class RequirementsSpecificationSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not RequirementsSpecification requirementsSpecification) - { - throw new ArgumentException("The thing shall be a RequirementsSpecification", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of RequirementsSpecification since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing RequirementsSpecification for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in requirementsSpecification.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirementsSpecification.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in requirementsSpecification.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("group"u8); - - foreach(var groupItem in requirementsSpecification.Group.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(groupItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in requirementsSpecification.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirementsSpecification.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(requirementsSpecification.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirementsSpecification.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirementsSpecification.Owner); - writer.WriteStartArray("requirement"u8); + writer.WriteStartArray("alias"u8); - foreach(var requirementItem in requirementsSpecification.Requirement.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(requirementItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirementsSpecification.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirementsSpecification.ShortName); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing RequirementsSpecification for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in requirementsSpecification.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in requirementsSpecification.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirementsSpecification.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in requirementsSpecification.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in requirementsSpecification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in requirementsSpecification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("group"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var groupItem in requirementsSpecification.Group.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(groupItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in requirementsSpecification.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirementsSpecification.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(requirementsSpecification.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirementsSpecification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirementsSpecification.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirementsSpecification.Owner); - writer.WriteStartArray("parameterValue"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var parameterValueItem in requirementsSpecification.ParameterValue.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(parameterValueItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("requirement"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var requirementItem in requirementsSpecification.Requirement.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(requirementItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirementsSpecification.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirementsSpecification.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing RequirementsSpecification for Version 1.2.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in requirementsSpecification.Alias.OrderBy(x => x, this.GuidComparer)) + case "excludedperson": + var allowedVersionsForExcludedPerson = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in requirementsSpecification.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirementsSpecification.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var definitionItem in requirementsSpecification.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(definitionItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "group": + var allowedVersionsForGroup = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in requirementsSpecification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForGroup.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("group"u8); - foreach(var excludedPersonItem in requirementsSpecification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListGroup) { - writer.WriteStringValue(excludedPersonItem); + foreach(var groupItem in objectListGroup.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(groupItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("group"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var groupItem in requirementsSpecification.Group.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(groupItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in requirementsSpecification.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirementsSpecification.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(requirementsSpecification.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirementsSpecification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirementsSpecification.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirementsSpecification.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in requirementsSpecification.ParameterValue.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterValueItem); - } - writer.WriteEndArray(); - - writer.WriteStartArray("requirement"u8); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var requirementItem in requirementsSpecification.Requirement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(requirementItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirementsSpecification.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirementsSpecification.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requirementsSpecification.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing RequirementsSpecification for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(requirementsSpecification.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(requirementsSpecification.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in requirementsSpecification.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in requirementsSpecification.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(requirementsSpecification.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in requirementsSpecification.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in requirementsSpecification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in requirementsSpecification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WriteStartArray("group"u8); - - foreach(var groupItem in requirementsSpecification.Group.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(groupItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in requirementsSpecification.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(requirementsSpecification.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(requirementsSpecification.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(requirementsSpecification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - writer.WriteStringValue(requirementsSpecification.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(requirementsSpecification.Owner); - writer.WriteStartArray("parameterValue"u8); - - foreach(var parameterValueItem in requirementsSpecification.ParameterValue.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(parameterValueItem); + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("requirement"u8); - - foreach(var requirementItem in requirementsSpecification.Requirement.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(requirementItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(requirementsSpecification.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(requirementsSpecification.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(requirementsSpecification.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "owner": + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("owner"u8); if(value != null) { @@ -491,53 +419,76 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "parametervalue": + var allowedVersionsForParameterValue = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterValue.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("parameterValue"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListParameterValue) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var parameterValueItem in objectListParameterValue.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteStringValue(parameterValueItem); } } writer.WriteEndArray(); break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "requirement": + var allowedVersionsForRequirement = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRequirement.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("requirement"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListRequirement) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var requirementItem in objectListRequirement.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(requirementItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteNumberValue((int)value); } else { @@ -545,306 +496,437 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List { - return; - } - - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDefinition) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + return; } + + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) + else { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "group": - if(!AllowedVersionsPerProperty["group"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("group"u8); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the RequirementsSpecification"); + } + } - if(value is IEnumerable objectListGroup) + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not RequirementsSpecification requirementsSpecification) + { + throw new ArgumentException("The thing shall be a RequirementsSpecification", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of RequirementsSpecification since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing RequirementsSpecification for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirementsSpecification.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var groupItem in objectListGroup.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(groupItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirementsSpecification.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirementsSpecification.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WriteStartArray("group"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var groupItem in requirementsSpecification.Group.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(groupItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in requirementsSpecification.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + writer.WriteStringValue(requirementsSpecification.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(requirementsSpecification.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(requirementsSpecification.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requirementsSpecification.Owner); + writer.WriteStartArray("requirement"u8); + + foreach(var requirementItem in requirementsSpecification.Requirement.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(requirementItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirementsSpecification.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requirementsSpecification.ShortName); break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing RequirementsSpecification for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirementsSpecification.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requirementsSpecification.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirementsSpecification.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirementsSpecification.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requirementsSpecification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requirementsSpecification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("group"u8); + + foreach(var groupItem in requirementsSpecification.Group.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(groupItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in requirementsSpecification.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirementsSpecification.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(requirementsSpecification.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirementsSpecification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteStringValue(requirementsSpecification.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requirementsSpecification.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in requirementsSpecification.ParameterValue.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(parameterValueItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("requirement"u8); + + foreach(var requirementItem in requirementsSpecification.Requirement.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(requirementItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirementsSpecification.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requirementsSpecification.ShortName); break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing RequirementsSpecification for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirementsSpecification.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("owner"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requirementsSpecification.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirementsSpecification.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirementsSpecification.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "parametervalue": - if(!AllowedVersionsPerProperty["parameterValue"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requirementsSpecification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WriteStartArray("parameterValue"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListParameterValue) + foreach(var excludedPersonItem in requirementsSpecification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - foreach(var parameterValueItem in objectListParameterValue.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterValueItem); - } + writer.WriteStringValue(excludedPersonItem); } - + writer.WriteEndArray(); - break; - case "requirement": - if(!AllowedVersionsPerProperty["requirement"].Contains(requestedVersion)) + writer.WriteStartArray("group"u8); + + foreach(var groupItem in requirementsSpecification.Group.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(groupItem); } - writer.WriteStartArray("requirement"u8); + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListRequirement) + foreach(var hyperLinkItem in requirementsSpecification.HyperLink.OrderBy(x => x, this.GuidComparer)) { - foreach(var requirementItem in objectListRequirement.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(requirementItem); - } + writer.WriteStringValue(hyperLinkItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirementsSpecification.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(requirementsSpecification.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirementsSpecification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(requirementsSpecification.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requirementsSpecification.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in requirementsSpecification.ParameterValue.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(parameterValueItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("requirement"u8); + + foreach(var requirementItem in requirementsSpecification.Requirement.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(requirementItem); } + writer.WriteEndArray(); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteNumberValue(requirementsSpecification.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requirementsSpecification.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(requirementsSpecification.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing RequirementsSpecification for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(requirementsSpecification.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(requirementsSpecification.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in requirementsSpecification.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in requirementsSpecification.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(requirementsSpecification.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in requirementsSpecification.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in requirementsSpecification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in requirementsSpecification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("group"u8); + + foreach(var groupItem in requirementsSpecification.Group.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(groupItem); } + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in requirementsSpecification.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(requirementsSpecification.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(requirementsSpecification.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(requirementsSpecification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(requirementsSpecification.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(requirementsSpecification.Owner); + writer.WriteStartArray("parameterValue"u8); + + foreach(var parameterValueItem in requirementsSpecification.ParameterValue.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterValueItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("requirement"u8); + + foreach(var requirementItem in requirementsSpecification.Requirement.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(requirementItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(requirementsSpecification.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(requirementsSpecification.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(requirementsSpecification.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the RequirementsSpecification"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "group", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterValue", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "requirement", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ReviewItemDiscrepancySerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ReviewItemDiscrepancySerializer.cs index bd78f134..ae3bf64b 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ReviewItemDiscrepancySerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ReviewItemDiscrepancySerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,445 +50,305 @@ namespace CDP4JsonSerializer public class ReviewItemDiscrepancySerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ReviewItemDiscrepancy reviewItemDiscrepancy) - { - throw new ArgumentException("The thing shall be a ReviewItemDiscrepancy", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ReviewItemDiscrepancy since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ReviewItemDiscrepancy for Version 1.1.0"); - writer.WriteStartArray("approvedBy"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var approvedByItem in reviewItemDiscrepancy.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in reviewItemDiscrepancy.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(reviewItemDiscrepancy.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(reviewItemDiscrepancy.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); + break; + case "approvedby": + var allowedVersionsForApprovedBy = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var discussionItem in reviewItemDiscrepancy.Discussion.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForApprovedBy.Contains(requestedVersion)) { - writer.WriteStringValue(discussionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("approvedBy"u8); - foreach(var excludedDomainItem in reviewItemDiscrepancy.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListApprovedBy) { - writer.WriteStringValue(excludedDomainItem); + foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(approvedByItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "author": + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in reviewItemDiscrepancy.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("author"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(reviewItemDiscrepancy.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(reviewItemDiscrepancy.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(reviewItemDiscrepancy.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(reviewItemDiscrepancy.PrimaryAnnotatedThing.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in reviewItemDiscrepancy.RelatedThing.OrderBy(x => x, this.GuidComparer)) + break; + case "category": + var allowedVersionsForCategory = new List { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(reviewItemDiscrepancy.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(reviewItemDiscrepancy.ShortName); - writer.WriteStartArray("solution"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var solutionItem in reviewItemDiscrepancy.Solution.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(solutionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("sourceAnnotation"u8); + writer.WriteStartArray("category"u8); - foreach(var sourceAnnotationItem in reviewItemDiscrepancy.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(sourceAnnotationItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Status.ToString()); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Title); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ReviewItemDiscrepancy for Version 1.2.0"); - writer.WriteStartArray("approvedBy"u8); - - foreach(var approvedByItem in reviewItemDiscrepancy.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + case "classification": + var allowedVersionsForClassification = new List { - writer.WriteStringValue(approvedByItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Author); - writer.WriteStartArray("category"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in reviewItemDiscrepancy.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassification.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(reviewItemDiscrepancy.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(reviewItemDiscrepancy.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in reviewItemDiscrepancy.Discussion.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(discussionItem); + writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in reviewItemDiscrepancy.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in reviewItemDiscrepancy.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(reviewItemDiscrepancy.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(reviewItemDiscrepancy.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(reviewItemDiscrepancy.PrimaryAnnotatedThing.HasValue) + if(value != null) { - writer.WriteStringValue(reviewItemDiscrepancy.PrimaryAnnotatedThing.Value); + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WriteStartArray("relatedThing"u8); + break; + case "content": + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var relatedThingItem in reviewItemDiscrepancy.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContent.Contains(requestedVersion)) { - writer.WriteStringValue(relatedThingItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("content"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(reviewItemDiscrepancy.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(reviewItemDiscrepancy.ShortName); - writer.WriteStartArray("solution"u8); - - foreach(var solutionItem in reviewItemDiscrepancy.Solution.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(solutionItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("sourceAnnotation"u8); + break; + case "createdon": + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var sourceAnnotationItem in reviewItemDiscrepancy.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { - writer.WriteStringValue(sourceAnnotationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("createdOn"u8); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(reviewItemDiscrepancy.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Title); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ReviewItemDiscrepancy for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(reviewItemDiscrepancy.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(reviewItemDiscrepancy.Actor.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("approvedBy"u8); + break; + case "discussion": + var allowedVersionsForDiscussion = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var approvedByItem in reviewItemDiscrepancy.ApprovedBy.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDiscussion.Contains(requestedVersion)) { - writer.WriteStringValue(approvedByItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Author); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in reviewItemDiscrepancy.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classification"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Classification.ToString()); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(reviewItemDiscrepancy.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(reviewItemDiscrepancy.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WriteStartArray("discussion"u8); - foreach(var discussionItem in reviewItemDiscrepancy.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in reviewItemDiscrepancy.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDiscussion) { - writer.WriteStringValue(excludedDomainItem); + foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in reviewItemDiscrepancy.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(reviewItemDiscrepancy.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(reviewItemDiscrepancy.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Owner); - writer.WritePropertyName("primaryAnnotatedThing"u8); - - if(reviewItemDiscrepancy.PrimaryAnnotatedThing.HasValue) - { - writer.WriteStringValue(reviewItemDiscrepancy.PrimaryAnnotatedThing.Value); - } - else + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteNullValue(); - } - - writer.WriteStartArray("relatedThing"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var relatedThingItem in reviewItemDiscrepancy.RelatedThing.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(relatedThingItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(reviewItemDiscrepancy.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(reviewItemDiscrepancy.ShortName); - writer.WriteStartArray("solution"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var solutionItem in reviewItemDiscrepancy.Solution.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(solutionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("sourceAnnotation"u8); - - foreach(var sourceAnnotationItem in reviewItemDiscrepancy.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sourceAnnotationItem); - } - writer.WriteEndArray(); - - writer.WritePropertyName("status"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(reviewItemDiscrepancy.ThingPreference); - writer.WritePropertyName("title"u8); - writer.WriteStringValue(reviewItemDiscrepancy.Title); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + case "excludedperson": + var allowedVersionsForExcludedPerson = new List { - writer.WriteNullValue(); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - break; - case "approvedby": - if(!AllowedVersionsPerProperty["approvedBy"].Contains(requestedVersion)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } - writer.WriteStartArray("approvedBy"u8); + writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListApprovedBy) + if(value is IEnumerable objectListExcludedPerson) { - foreach(var approvedByItem in objectListApprovedBy.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(approvedByItem); + writer.WriteStringValue(excludedPersonItem); } } writer.WriteEndArray(); break; - case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } - writer.WritePropertyName("author"u8); + writer.WritePropertyName("iid"u8); if(value != null) { @@ -501,35 +360,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "languagecode": + var allowedVersionsForLanguageCode = new List { - return; - } - - writer.WriteStartArray("category"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListCategory) - { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - } - - writer.WriteEndArray(); - break; - case "classification": - if(!AllowedVersionsPerProperty["classification"].Contains(requestedVersion)) + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classification"u8); + writer.WritePropertyName("languageCode"u8); if(value != null) { - writer.WriteStringValue(((AnnotationClassificationKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -537,17 +385,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -555,17 +410,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + case "owner": + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } - writer.WritePropertyName("content"u8); + writer.WritePropertyName("owner"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue((Guid)value); } else { @@ -573,17 +435,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + case "primaryannotatedthing": + var allowedVersionsForPrimaryAnnotatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPrimaryAnnotatedThing.Contains(requestedVersion)) { return; } - writer.WritePropertyName("createdOn"u8); + writer.WritePropertyName("primaryAnnotatedThing"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((Guid)value); } else { @@ -591,71 +460,49 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "discussion": - if(!AllowedVersionsPerProperty["discussion"].Contains(requestedVersion)) + case "relatedthing": + var allowedVersionsForRelatedThing = new List { - return; - } - - writer.WriteStartArray("discussion"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDiscussion) - { - foreach(var discussionItem in objectListDiscussion.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForRelatedThing.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("relatedThing"u8); - if(value is IEnumerable objectListExcludedDomain) + if(value is IEnumerable objectListRelatedThing) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(relatedThingItem); } } writer.WriteEndArray(); break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } - - writer.WriteStartArray("excludedPerson"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -663,13 +510,20 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("languageCode"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { @@ -681,17 +535,74 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "solution": + var allowedVersionsForSolution = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSolution.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); - + writer.WriteStartArray("solution"u8); + + if(value is IEnumerable objectListSolution) + { + foreach(var solutionItem in objectListSolution.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(solutionItem); + } + } + + writer.WriteEndArray(); + break; + case "sourceannotation": + var allowedVersionsForSourceAnnotation = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSourceAnnotation.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("sourceAnnotation"u8); + + if(value is IEnumerable objectListSourceAnnotation) + { + foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); + } + } + + writer.WriteEndArray(); + break; + case "status": + var allowedVersionsForStatus = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStatus.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("status"u8); + if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); } else { @@ -699,17 +610,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("owner"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -717,17 +634,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "primaryannotatedthing": - if(!AllowedVersionsPerProperty["primaryAnnotatedThing"].Contains(requestedVersion)) + case "title": + var allowedVersionsForTitle = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForTitle.Contains(requestedVersion)) { return; } - writer.WritePropertyName("primaryAnnotatedThing"u8); + writer.WritePropertyName("title"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -735,185 +659,369 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "relatedthing": - if(!AllowedVersionsPerProperty["relatedThing"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ReviewItemDiscrepancy"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ReviewItemDiscrepancy reviewItemDiscrepancy) + { + throw new ArgumentException("The thing shall be a ReviewItemDiscrepancy", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ReviewItemDiscrepancy since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ReviewItemDiscrepancy for Version 1.1.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in reviewItemDiscrepancy.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WriteStartArray("relatedThing"u8); + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Author); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListRelatedThing) + foreach(var categoryItem in reviewItemDiscrepancy.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var relatedThingItem in objectListRelatedThing.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(reviewItemDiscrepancy.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(reviewItemDiscrepancy.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in reviewItemDiscrepancy.Discussion.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(discussionItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in reviewItemDiscrepancy.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in reviewItemDiscrepancy.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(reviewItemDiscrepancy.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(reviewItemDiscrepancy.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(reviewItemDiscrepancy.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(reviewItemDiscrepancy.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in reviewItemDiscrepancy.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); } + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(reviewItemDiscrepancy.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(reviewItemDiscrepancy.ShortName); + writer.WriteStartArray("solution"u8); + + foreach(var solutionItem in reviewItemDiscrepancy.Solution.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(solutionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in reviewItemDiscrepancy.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(sourceAnnotationItem); } + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Status.ToString()); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Title); break; - case "solution": - if(!AllowedVersionsPerProperty["solution"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ReviewItemDiscrepancy for Version 1.2.0"); + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in reviewItemDiscrepancy.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WriteStartArray("solution"u8); + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Author); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListSolution) + foreach(var categoryItem in reviewItemDiscrepancy.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var solutionItem in objectListSolution.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(solutionItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "sourceannotation": - if(!AllowedVersionsPerProperty["sourceAnnotation"].Contains(requestedVersion)) + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(reviewItemDiscrepancy.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(reviewItemDiscrepancy.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in reviewItemDiscrepancy.Discussion.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(discussionItem); } - writer.WriteStartArray("sourceAnnotation"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListSourceAnnotation) + foreach(var excludedDomainItem in reviewItemDiscrepancy.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var sourceAnnotationItem in objectListSourceAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(sourceAnnotationItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "status": - if(!AllowedVersionsPerProperty["status"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in reviewItemDiscrepancy.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("status"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(reviewItemDiscrepancy.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(reviewItemDiscrepancy.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(reviewItemDiscrepancy.PrimaryAnnotatedThing.HasValue) { - writer.WriteStringValue(((AnnotationStatusKind)value).ToString()); + writer.WriteStringValue(reviewItemDiscrepancy.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in reviewItemDiscrepancy.RelatedThing.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(reviewItemDiscrepancy.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(reviewItemDiscrepancy.ShortName); + writer.WriteStartArray("solution"u8); + + foreach(var solutionItem in reviewItemDiscrepancy.Solution.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(solutionItem); } + writer.WriteEndArray(); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in reviewItemDiscrepancy.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Status.ToString()); writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteStringValue(reviewItemDiscrepancy.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Title); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ReviewItemDiscrepancy for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(reviewItemDiscrepancy.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(reviewItemDiscrepancy.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "title": - if(!AllowedVersionsPerProperty["title"].Contains(requestedVersion)) + writer.WriteStartArray("approvedBy"u8); + + foreach(var approvedByItem in reviewItemDiscrepancy.ApprovedBy.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(approvedByItem); } - writer.WritePropertyName("title"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Author); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in reviewItemDiscrepancy.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classification"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Classification.ToString()); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(reviewItemDiscrepancy.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(reviewItemDiscrepancy.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in reviewItemDiscrepancy.Discussion.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in reviewItemDiscrepancy.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in reviewItemDiscrepancy.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(reviewItemDiscrepancy.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(reviewItemDiscrepancy.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Owner); + writer.WritePropertyName("primaryAnnotatedThing"u8); + + if(reviewItemDiscrepancy.PrimaryAnnotatedThing.HasValue) + { + writer.WriteStringValue(reviewItemDiscrepancy.PrimaryAnnotatedThing.Value); } else { writer.WriteNullValue(); } + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in reviewItemDiscrepancy.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(reviewItemDiscrepancy.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(reviewItemDiscrepancy.ShortName); + writer.WriteStartArray("solution"u8); + + foreach(var solutionItem in reviewItemDiscrepancy.Solution.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(solutionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("sourceAnnotation"u8); + + foreach(var sourceAnnotationItem in reviewItemDiscrepancy.SourceAnnotation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(sourceAnnotationItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(reviewItemDiscrepancy.ThingPreference); + writer.WritePropertyName("title"u8); + writer.WriteStringValue(reviewItemDiscrepancy.Title); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ReviewItemDiscrepancy"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "approvedBy", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classification", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "discussion", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "primaryAnnotatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "relatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "solution", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "sourceAnnotation", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "status", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "title", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/RuleVerificationListSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/RuleVerificationListSerializer.cs index 5cf08a6b..4da2b357 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/RuleVerificationListSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/RuleVerificationListSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,341 +50,317 @@ namespace CDP4JsonSerializer public class RuleVerificationListSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not RuleVerificationList ruleVerificationList) - { - throw new ArgumentException("The thing shall be a RuleVerificationList", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of RuleVerificationList since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing RuleVerificationList for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in ruleVerificationList.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ruleVerificationList.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in ruleVerificationList.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in ruleVerificationList.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ruleVerificationList.Iid); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ruleVerificationList.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(ruleVerificationList.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ruleVerificationList.RevisionNumber); - writer.WriteStartArray("ruleVerification"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var ruleVerificationItem in ruleVerificationList.RuleVerification.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteOrderedItem(ruleVerificationItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ruleVerificationList.ShortName); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing RuleVerificationList for Version 1.1.0"); writer.WriteStartArray("alias"u8); - foreach(var aliasItem in ruleVerificationList.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(aliasItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ruleVerificationList.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in ruleVerificationList.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in ruleVerificationList.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in ruleVerificationList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in ruleVerificationList.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ruleVerificationList.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ruleVerificationList.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ruleVerificationList.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(ruleVerificationList.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ruleVerificationList.RevisionNumber); - writer.WriteStartArray("ruleVerification"u8); + writer.WriteStartArray("definition"u8); - foreach(var ruleVerificationItem in ruleVerificationList.RuleVerification.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteOrderedItem(ruleVerificationItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ruleVerificationList.ShortName); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing RuleVerificationList for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in ruleVerificationList.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ruleVerificationList.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in ruleVerificationList.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in ruleVerificationList.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in ruleVerificationList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in ruleVerificationList.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ruleVerificationList.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ruleVerificationList.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ruleVerificationList.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(ruleVerificationList.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ruleVerificationList.RevisionNumber); - writer.WriteStartArray("ruleVerification"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var ruleVerificationItem in ruleVerificationList.RuleVerification.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteOrderedItem(ruleVerificationItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ruleVerificationList.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(ruleVerificationList.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing RuleVerificationList for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(ruleVerificationList.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(ruleVerificationList.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in ruleVerificationList.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ruleVerificationList.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in ruleVerificationList.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in ruleVerificationList.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in ruleVerificationList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "owner": + var allowedVersionsForOwner = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in ruleVerificationList.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForOwner.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ruleVerificationList.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ruleVerificationList.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(ruleVerificationList.Name); writer.WritePropertyName("owner"u8); - writer.WriteStringValue(ruleVerificationList.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ruleVerificationList.RevisionNumber); - writer.WriteStartArray("ruleVerification"u8); - - foreach(var ruleVerificationItem in ruleVerificationList.RuleVerification.OrderBy(x => x, this.OrderedItemComparer)) + + if(value != null) { - writer.WriteOrderedItem(ruleVerificationItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(ruleVerificationList.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(ruleVerificationList.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -393,35 +368,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "ruleverification": + var allowedVersionsForRuleVerification = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRuleVerification.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("ruleVerification"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListRuleVerification) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var ruleVerificationItem in objectListRuleVerification.OfType().OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteOrderedItem(ruleVerificationItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -429,248 +420,323 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedDomain"u8); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the RuleVerificationList"); + } + } - if(value is IEnumerable objectListExcludedDomain) + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not RuleVerificationList ruleVerificationList) + { + throw new ArgumentException("The thing shall be a RuleVerificationList", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of RuleVerificationList since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing RuleVerificationList for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in ruleVerificationList.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ruleVerificationList.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in ruleVerificationList.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var hyperLinkItem in ruleVerificationList.HyperLink.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(hyperLinkItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ruleVerificationList.Iid); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ruleVerificationList.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(ruleVerificationList.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ruleVerificationList.RevisionNumber); + writer.WriteStartArray("ruleVerification"u8); + + foreach(var ruleVerificationItem in ruleVerificationList.RuleVerification.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(ruleVerificationItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ruleVerificationList.ShortName); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing RuleVerificationList for Version 1.1.0"); + writer.WriteStartArray("alias"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var aliasItem in ruleVerificationList.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ruleVerificationList.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in ruleVerificationList.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ruleVerificationList.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ruleVerificationList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in ruleVerificationList.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ruleVerificationList.Iid); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else + writer.WriteStringValue(ruleVerificationList.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ruleVerificationList.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(ruleVerificationList.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ruleVerificationList.RevisionNumber); + writer.WriteStartArray("ruleVerification"u8); + + foreach(var ruleVerificationItem in ruleVerificationList.RuleVerification.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(ruleVerificationItem); } + writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ruleVerificationList.ShortName); break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing RuleVerificationList for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in ruleVerificationList.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ruleVerificationList.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in ruleVerificationList.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ruleVerificationList.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ruleVerificationList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("owner"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in ruleVerificationList.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ruleVerificationList.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ruleVerificationList.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ruleVerificationList.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(ruleVerificationList.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ruleVerificationList.RevisionNumber); + writer.WriteStartArray("ruleVerification"u8); + + foreach(var ruleVerificationItem in ruleVerificationList.RuleVerification.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(ruleVerificationItem); } + writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ruleVerificationList.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(ruleVerificationList.ThingPreference); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing RuleVerificationList for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(ruleVerificationList.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(ruleVerificationList.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "ruleverification": - if(!AllowedVersionsPerProperty["ruleVerification"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in ruleVerificationList.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("ruleVerification"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ruleVerificationList.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListRuleVerification) + foreach(var definitionItem in ruleVerificationList.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var ruleVerificationItem in objectListRuleVerification.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(ruleVerificationItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("excludedDomain"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else + foreach(var excludedDomainItem in ruleVerificationList.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ruleVerificationList.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in ruleVerificationList.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ruleVerificationList.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ruleVerificationList.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(ruleVerificationList.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(ruleVerificationList.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ruleVerificationList.RevisionNumber); + writer.WriteStartArray("ruleVerification"u8); + + foreach(var ruleVerificationItem in ruleVerificationList.RuleVerification.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNullValue(); + writer.WriteOrderedItem(ruleVerificationItem); } + writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(ruleVerificationList.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(ruleVerificationList.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the RuleVerificationList"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "ruleVerification", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/RuleViolationSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/RuleViolationSerializer.cs index a37d9bcd..e7f25e74 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/RuleViolationSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/RuleViolationSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,193 +49,6 @@ namespace CDP4JsonSerializer /// public class RuleViolationSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not RuleViolation ruleViolation) - { - throw new ArgumentException("The thing shall be a RuleViolation", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of RuleViolation since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing RuleViolation for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ruleViolation.ClassKind.ToString()); - writer.WritePropertyName("description"u8); - writer.WriteStringValue(ruleViolation.Description); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ruleViolation.Iid); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ruleViolation.RevisionNumber); - writer.WriteStartArray("violatingThing"u8); - - foreach(var violatingThingItem in ruleViolation.ViolatingThing) - { - writer.WriteStringValue(violatingThingItem); - } - - writer.WriteEndArray(); - - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing RuleViolation for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ruleViolation.ClassKind.ToString()); - writer.WritePropertyName("description"u8); - writer.WriteStringValue(ruleViolation.Description); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in ruleViolation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in ruleViolation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ruleViolation.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ruleViolation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ruleViolation.RevisionNumber); - writer.WriteStartArray("violatingThing"u8); - - foreach(var violatingThingItem in ruleViolation.ViolatingThing) - { - writer.WriteStringValue(violatingThingItem); - } - - writer.WriteEndArray(); - - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing RuleViolation for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ruleViolation.ClassKind.ToString()); - writer.WritePropertyName("description"u8); - writer.WriteStringValue(ruleViolation.Description); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in ruleViolation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in ruleViolation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ruleViolation.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ruleViolation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ruleViolation.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(ruleViolation.ThingPreference); - writer.WriteStartArray("violatingThing"u8); - - foreach(var violatingThingItem in ruleViolation.ViolatingThing) - { - writer.WriteStringValue(violatingThingItem); - } - - writer.WriteEndArray(); - - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing RuleViolation for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(ruleViolation.Actor.HasValue) - { - writer.WriteStringValue(ruleViolation.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(ruleViolation.ClassKind.ToString()); - writer.WritePropertyName("description"u8); - writer.WriteStringValue(ruleViolation.Description); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in ruleViolation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in ruleViolation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(ruleViolation.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(ruleViolation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(ruleViolation.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(ruleViolation.ThingPreference); - writer.WriteStartArray("violatingThing"u8); - - foreach(var violatingThingItem in ruleViolation.ViolatingThing) - { - writer.WriteStringValue(violatingThingItem); - } - - writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -244,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -252,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -270,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -288,7 +112,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "description": - if(!AllowedVersionsPerProperty["description"].Contains(requestedVersion)) + var allowedVersionsForDescription = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDescription.Contains(requestedVersion)) { return; } @@ -306,7 +138,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -324,7 +163,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -342,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -360,7 +214,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -378,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -396,7 +265,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -414,7 +289,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "violatingthing": - if(!AllowedVersionsPerProperty["violatingThing"].Contains(requestedVersion)) + var allowedVersionsForViolatingThing = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForViolatingThing.Contains(requestedVersion)) { return; } @@ -437,21 +320,181 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "description", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "violatingThing", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not RuleViolation ruleViolation) + { + throw new ArgumentException("The thing shall be a RuleViolation", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of RuleViolation since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing RuleViolation for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ruleViolation.ClassKind.ToString()); + writer.WritePropertyName("description"u8); + writer.WriteStringValue(ruleViolation.Description); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ruleViolation.Iid); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ruleViolation.RevisionNumber); + writer.WriteStartArray("violatingThing"u8); + + foreach(var violatingThingItem in ruleViolation.ViolatingThing) + { + writer.WriteStringValue(violatingThingItem); + } + + writer.WriteEndArray(); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing RuleViolation for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ruleViolation.ClassKind.ToString()); + writer.WritePropertyName("description"u8); + writer.WriteStringValue(ruleViolation.Description); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ruleViolation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ruleViolation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ruleViolation.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ruleViolation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ruleViolation.RevisionNumber); + writer.WriteStartArray("violatingThing"u8); + + foreach(var violatingThingItem in ruleViolation.ViolatingThing) + { + writer.WriteStringValue(violatingThingItem); + } + + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing RuleViolation for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ruleViolation.ClassKind.ToString()); + writer.WritePropertyName("description"u8); + writer.WriteStringValue(ruleViolation.Description); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ruleViolation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ruleViolation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ruleViolation.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ruleViolation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ruleViolation.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(ruleViolation.ThingPreference); + writer.WriteStartArray("violatingThing"u8); + + foreach(var violatingThingItem in ruleViolation.ViolatingThing) + { + writer.WriteStringValue(violatingThingItem); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing RuleViolation for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(ruleViolation.Actor.HasValue) + { + writer.WriteStringValue(ruleViolation.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(ruleViolation.ClassKind.ToString()); + writer.WritePropertyName("description"u8); + writer.WriteStringValue(ruleViolation.Description); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in ruleViolation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in ruleViolation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(ruleViolation.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(ruleViolation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(ruleViolation.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(ruleViolation.ThingPreference); + writer.WriteStartArray("violatingThing"u8); + + foreach(var violatingThingItem in ruleViolation.ViolatingThing) + { + writer.WriteStringValue(violatingThingItem); + } + + writer.WriteEndArray(); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SampledFunctionParameterTypeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SampledFunctionParameterTypeSerializer.cs index 80cb8479..1ba4dc61 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SampledFunctionParameterTypeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SampledFunctionParameterTypeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,259 +49,6 @@ namespace CDP4JsonSerializer /// public class SampledFunctionParameterTypeSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not SampledFunctionParameterType sampledFunctionParameterType) - { - throw new ArgumentException("The thing shall be a SampledFunctionParameterType", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.2.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of SampledFunctionParameterType since Version is below 1.2.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SampledFunctionParameterType for Version 1.2.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in sampledFunctionParameterType.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in sampledFunctionParameterType.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(sampledFunctionParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in sampledFunctionParameterType.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("degreeOfInterpolation"u8); - - if(sampledFunctionParameterType.DegreeOfInterpolation.HasValue) - { - writer.WriteNumberValue(sampledFunctionParameterType.DegreeOfInterpolation.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("dependentParameterType"u8); - - foreach(var dependentParameterTypeItem in sampledFunctionParameterType.DependentParameterType.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(dependentParameterTypeItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in sampledFunctionParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in sampledFunctionParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in sampledFunctionParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(sampledFunctionParameterType.Iid); - writer.WriteStartArray("independentParameterType"u8); - - foreach(var independentParameterTypeItem in sampledFunctionParameterType.IndependentParameterType.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(independentParameterTypeItem); - } - - writer.WriteEndArray(); - - writer.WriteString("interpolationPeriod"u8, sampledFunctionParameterType.InterpolationPeriod.ToJsonString()); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(sampledFunctionParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(sampledFunctionParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(sampledFunctionParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(sampledFunctionParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(sampledFunctionParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(sampledFunctionParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(sampledFunctionParameterType.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SampledFunctionParameterType for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(sampledFunctionParameterType.Actor.HasValue) - { - writer.WriteStringValue(sampledFunctionParameterType.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in sampledFunctionParameterType.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in sampledFunctionParameterType.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(sampledFunctionParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in sampledFunctionParameterType.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("degreeOfInterpolation"u8); - - if(sampledFunctionParameterType.DegreeOfInterpolation.HasValue) - { - writer.WriteNumberValue(sampledFunctionParameterType.DegreeOfInterpolation.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("dependentParameterType"u8); - - foreach(var dependentParameterTypeItem in sampledFunctionParameterType.DependentParameterType.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(dependentParameterTypeItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in sampledFunctionParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in sampledFunctionParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in sampledFunctionParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(sampledFunctionParameterType.Iid); - writer.WriteStartArray("independentParameterType"u8); - - foreach(var independentParameterTypeItem in sampledFunctionParameterType.IndependentParameterType.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(independentParameterTypeItem); - } - - writer.WriteEndArray(); - - writer.WriteString("interpolationPeriod"u8, sampledFunctionParameterType.InterpolationPeriod.ToJsonString()); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(sampledFunctionParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(sampledFunctionParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(sampledFunctionParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(sampledFunctionParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(sampledFunctionParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(sampledFunctionParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(sampledFunctionParameterType.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -310,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -318,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -336,7 +86,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + var allowedVersionsForAlias = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) { return; } @@ -354,7 +110,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + var allowedVersionsForCategory = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) { return; } @@ -372,7 +134,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -390,7 +158,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + var allowedVersionsForDefinition = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { return; } @@ -408,7 +182,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "degreeofinterpolation": - if(!AllowedVersionsPerProperty["degreeOfInterpolation"].Contains(requestedVersion)) + var allowedVersionsForDegreeOfInterpolation = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDegreeOfInterpolation.Contains(requestedVersion)) { return; } @@ -426,7 +206,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "dependentparametertype": - if(!AllowedVersionsPerProperty["dependentParameterType"].Contains(requestedVersion)) + var allowedVersionsForDependentParameterType = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDependentParameterType.Contains(requestedVersion)) { return; } @@ -444,7 +230,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -462,7 +255,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -480,7 +280,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + var allowedVersionsForHyperLink = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { return; } @@ -498,7 +304,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -516,7 +328,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "independentparametertype": - if(!AllowedVersionsPerProperty["independentParameterType"].Contains(requestedVersion)) + var allowedVersionsForIndependentParameterType = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIndependentParameterType.Contains(requestedVersion)) { return; } @@ -534,7 +352,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "interpolationperiod": - if(!AllowedVersionsPerProperty["interpolationPeriod"].Contains(requestedVersion)) + var allowedVersionsForInterpolationPeriod = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForInterpolationPeriod.Contains(requestedVersion)) { return; } @@ -542,7 +366,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteString("interpolationPeriod"u8, ((ValueArray)value).ToJsonString()); break; case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + var allowedVersionsForIsDeprecated = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { return; } @@ -560,7 +390,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -578,7 +415,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -596,7 +439,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -614,7 +463,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -632,7 +487,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + var allowedVersionsForSymbol = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { return; } @@ -650,7 +511,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -673,31 +540,241 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.2.0", "1.3.0" }}, - { "category", new []{ "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.2.0", "1.3.0" }}, - { "degreeOfInterpolation", new []{ "1.2.0", "1.3.0" }}, - { "dependentParameterType", new []{ "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.2.0", "1.3.0" }}, - { "independentParameterType", new []{ "1.2.0", "1.3.0" }}, - { "interpolationPeriod", new []{ "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not SampledFunctionParameterType sampledFunctionParameterType) + { + throw new ArgumentException("The thing shall be a SampledFunctionParameterType", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.2.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SampledFunctionParameterType since Version is below 1.2.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SampledFunctionParameterType for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in sampledFunctionParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in sampledFunctionParameterType.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(sampledFunctionParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in sampledFunctionParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("degreeOfInterpolation"u8); + + if(sampledFunctionParameterType.DegreeOfInterpolation.HasValue) + { + writer.WriteNumberValue(sampledFunctionParameterType.DegreeOfInterpolation.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("dependentParameterType"u8); + + foreach(var dependentParameterTypeItem in sampledFunctionParameterType.DependentParameterType.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(dependentParameterTypeItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in sampledFunctionParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in sampledFunctionParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in sampledFunctionParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(sampledFunctionParameterType.Iid); + writer.WriteStartArray("independentParameterType"u8); + + foreach(var independentParameterTypeItem in sampledFunctionParameterType.IndependentParameterType.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(independentParameterTypeItem); + } + + writer.WriteEndArray(); + writer.WriteString("interpolationPeriod"u8, sampledFunctionParameterType.InterpolationPeriod.ToJsonString()); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(sampledFunctionParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(sampledFunctionParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(sampledFunctionParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(sampledFunctionParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(sampledFunctionParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(sampledFunctionParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(sampledFunctionParameterType.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SampledFunctionParameterType for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(sampledFunctionParameterType.Actor.HasValue) + { + writer.WriteStringValue(sampledFunctionParameterType.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in sampledFunctionParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in sampledFunctionParameterType.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(sampledFunctionParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in sampledFunctionParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("degreeOfInterpolation"u8); + + if(sampledFunctionParameterType.DegreeOfInterpolation.HasValue) + { + writer.WriteNumberValue(sampledFunctionParameterType.DegreeOfInterpolation.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("dependentParameterType"u8); + + foreach(var dependentParameterTypeItem in sampledFunctionParameterType.DependentParameterType.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(dependentParameterTypeItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in sampledFunctionParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in sampledFunctionParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in sampledFunctionParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(sampledFunctionParameterType.Iid); + writer.WriteStartArray("independentParameterType"u8); + + foreach(var independentParameterTypeItem in sampledFunctionParameterType.IndependentParameterType.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(independentParameterTypeItem); + } + + writer.WriteEndArray(); + writer.WriteString("interpolationPeriod"u8, sampledFunctionParameterType.InterpolationPeriod.ToJsonString()); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(sampledFunctionParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(sampledFunctionParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(sampledFunctionParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(sampledFunctionParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(sampledFunctionParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(sampledFunctionParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(sampledFunctionParameterType.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ScaleReferenceQuantityValueSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ScaleReferenceQuantityValueSerializer.cs index 5852aa47..e6548525 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ScaleReferenceQuantityValueSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ScaleReferenceQuantityValueSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,165 +49,6 @@ namespace CDP4JsonSerializer /// public class ScaleReferenceQuantityValueSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ScaleReferenceQuantityValue scaleReferenceQuantityValue) - { - throw new ArgumentException("The thing shall be a ScaleReferenceQuantityValue", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ScaleReferenceQuantityValue since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ScaleReferenceQuantityValue for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Iid); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(scaleReferenceQuantityValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Scale); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Value); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ScaleReferenceQuantityValue for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in scaleReferenceQuantityValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in scaleReferenceQuantityValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(scaleReferenceQuantityValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Scale); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Value); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ScaleReferenceQuantityValue for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in scaleReferenceQuantityValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in scaleReferenceQuantityValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(scaleReferenceQuantityValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Scale); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.ThingPreference); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Value); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ScaleReferenceQuantityValue for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(scaleReferenceQuantityValue.Actor.HasValue) - { - writer.WriteStringValue(scaleReferenceQuantityValue.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in scaleReferenceQuantityValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in scaleReferenceQuantityValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(scaleReferenceQuantityValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Scale); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.ThingPreference); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(scaleReferenceQuantityValue.Value); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -216,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -224,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -242,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -260,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -278,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -296,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -314,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -332,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -350,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "scale": - if(!AllowedVersionsPerProperty["scale"].Contains(requestedVersion)) + var allowedVersionsForScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForScale.Contains(requestedVersion)) { return; } @@ -368,7 +265,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -386,7 +289,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "value": - if(!AllowedVersionsPerProperty["value"].Contains(requestedVersion)) + var allowedVersionsForValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValue.Contains(requestedVersion)) { return; } @@ -409,21 +320,157 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "scale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "value", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not ScaleReferenceQuantityValue scaleReferenceQuantityValue) + { + throw new ArgumentException("The thing shall be a ScaleReferenceQuantityValue", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ScaleReferenceQuantityValue since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ScaleReferenceQuantityValue for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Iid); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(scaleReferenceQuantityValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Scale); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Value); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ScaleReferenceQuantityValue for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in scaleReferenceQuantityValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in scaleReferenceQuantityValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(scaleReferenceQuantityValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Scale); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Value); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ScaleReferenceQuantityValue for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in scaleReferenceQuantityValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in scaleReferenceQuantityValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(scaleReferenceQuantityValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Scale); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.ThingPreference); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Value); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ScaleReferenceQuantityValue for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(scaleReferenceQuantityValue.Actor.HasValue) + { + writer.WriteStringValue(scaleReferenceQuantityValue.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in scaleReferenceQuantityValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in scaleReferenceQuantityValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(scaleReferenceQuantityValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Scale); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.ThingPreference); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(scaleReferenceQuantityValue.Value); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ScaleValueDefinitionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ScaleValueDefinitionSerializer.cs index b1adb3c9..492f146e 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ScaleValueDefinitionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ScaleValueDefinitionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,112 +50,424 @@ namespace CDP4JsonSerializer public class ScaleValueDefinitionSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not ScaleValueDefinition scaleValueDefinition) - { - throw new ArgumentException("The thing shall be a ScaleValueDefinition", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.0.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of ScaleValueDefinition since Version is below 1.0.0"); - return; - } + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - writer.WriteStartObject(); + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing ScaleValueDefinition for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var aliasItem in scaleValueDefinition.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "alias": + var allowedVersionsForAlias = new List { - writer.WriteStringValue(aliasItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WriteStartArray("alias"u8); + + if(value is IEnumerable objectListAlias) + { + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + } + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(scaleValueDefinition.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } - foreach(var definitionItem in scaleValueDefinition.Definition.OrderBy(x => x, this.GuidComparer)) + break; + case "definition": + var allowedVersionsForDefinition = new List { - writer.WriteStringValue(definitionItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefinition.Contains(requestedVersion)) + { + return; } + writer.WriteStartArray("definition"u8); + + if(value is IEnumerable objectListDefinition) + { + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + } + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in scaleValueDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("iid"u8); - writer.WriteStringValue(scaleValueDefinition.Iid); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("name"u8); - writer.WriteStringValue(scaleValueDefinition.Name); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(scaleValueDefinition.RevisionNumber); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(scaleValueDefinition.ShortName); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(scaleValueDefinition.Value); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ScaleValueDefinition for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in scaleValueDefinition.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(scaleValueDefinition.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var definitionItem in scaleValueDefinition.Definition.OrderBy(x => x, this.GuidComparer)) + break; + case "value": + var allowedVersionsForValue = new List { - writer.WriteStringValue(definitionItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValue.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("value"u8); - writer.WriteStartArray("excludedDomain"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedDomainItem in scaleValueDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the ScaleValueDefinition"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not ScaleValueDefinition scaleValueDefinition) + { + throw new ArgumentException("The thing shall be a ScaleValueDefinition", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ScaleValueDefinition since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing ScaleValueDefinition for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in scaleValueDefinition.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(aliasItem); } writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(scaleValueDefinition.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - foreach(var excludedPersonItem in scaleValueDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + foreach(var definitionItem in scaleValueDefinition.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(definitionItem); } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in scaleValueDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -165,11 +476,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(scaleValueDefinition.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(scaleValueDefinition.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); writer.WriteStringValue(scaleValueDefinition.Name); writer.WritePropertyName("revisionNumber"u8); @@ -179,8 +487,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WritePropertyName("value"u8); writer.WriteStringValue(scaleValueDefinition.Value); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ScaleValueDefinition for Version 1.2.0"); + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ScaleValueDefinition for Version 1.1.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in scaleValueDefinition.Alias.OrderBy(x => x, this.GuidComparer)) @@ -189,7 +497,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(scaleValueDefinition.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -200,7 +507,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in scaleValueDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -209,7 +515,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in scaleValueDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -218,7 +523,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in scaleValueDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -227,7 +531,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(scaleValueDefinition.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -238,24 +541,11 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNumberValue(scaleValueDefinition.RevisionNumber); writer.WritePropertyName("shortName"u8); writer.WriteStringValue(scaleValueDefinition.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(scaleValueDefinition.ThingPreference); writer.WritePropertyName("value"u8); writer.WriteStringValue(scaleValueDefinition.Value); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ScaleValueDefinition for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(scaleValueDefinition.Actor.HasValue) - { - writer.WriteStringValue(scaleValueDefinition.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ScaleValueDefinition for Version 1.2.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in scaleValueDefinition.Alias.OrderBy(x => x, this.GuidComparer)) @@ -264,7 +554,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(scaleValueDefinition.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -275,7 +564,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in scaleValueDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -284,7 +572,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in scaleValueDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -293,7 +580,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in scaleValueDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -302,7 +588,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(scaleValueDefinition.Iid); writer.WritePropertyName("modifiedOn"u8); @@ -318,304 +603,82 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WritePropertyName("value"u8); writer.WriteStringValue(scaleValueDefinition.Value); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ScaleValueDefinition for Version 1.3.0"); writer.WritePropertyName("actor"u8); - - if(value != null) + + if(scaleValueDefinition.Actor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(scaleValueDefinition.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - writer.WriteStartArray("alias"u8); - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + foreach(var aliasItem in scaleValueDefinition.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } + writer.WriteEndArray(); writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(scaleValueDefinition.ClassKind.ToString()); writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + foreach(var definitionItem in scaleValueDefinition.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + foreach(var excludedDomainItem in scaleValueDefinition.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + foreach(var excludedPersonItem in scaleValueDefinition.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + foreach(var hyperLinkItem in scaleValueDefinition.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(scaleValueDefinition.Iid); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(scaleValueDefinition.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(scaleValueDefinition.Name); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } - + writer.WriteNumberValue(scaleValueDefinition.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(scaleValueDefinition.ShortName); writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "value": - if(!AllowedVersionsPerProperty["value"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(scaleValueDefinition.ThingPreference); writer.WritePropertyName("value"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - + writer.WriteStringValue(scaleValueDefinition.Value); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the ScaleValueDefinition"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "value", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SectionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SectionSerializer.cs index 3d4aa0bf..49fb9fa5 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SectionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SectionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,218 +49,6 @@ namespace CDP4JsonSerializer /// public class SectionSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Section section) - { - throw new ArgumentException("The thing shall be a Section", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Section since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Section for Version 1.1.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in section.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(section.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(section.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in section.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in section.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(section.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(section.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(section.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(section.Owner); - writer.WriteStartArray("page"u8); - - foreach(var pageItem in section.Page.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(pageItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(section.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(section.ShortName); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Section for Version 1.2.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in section.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(section.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(section.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in section.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in section.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(section.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(section.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(section.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(section.Owner); - writer.WriteStartArray("page"u8); - - foreach(var pageItem in section.Page.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(pageItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(section.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(section.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(section.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Section for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(section.Actor.HasValue) - { - writer.WriteStringValue(section.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in section.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(section.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(section.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in section.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in section.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(section.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(section.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(section.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(section.Owner); - writer.WriteStartArray("page"u8); - - foreach(var pageItem in section.Page.OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(pageItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(section.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(section.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(section.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -269,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -277,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -295,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) { return; } @@ -313,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -331,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -349,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -367,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -385,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -403,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -421,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -439,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -457,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "page": - if(!AllowedVersionsPerProperty["page"].Contains(requestedVersion)) + var allowedVersionsForPage = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPage.Contains(requestedVersion)) { return; } @@ -475,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -493,7 +361,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -511,7 +386,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -534,25 +415,204 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "page", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Section section) + { + throw new ArgumentException("The thing shall be a Section", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Section since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Section for Version 1.1.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in section.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(section.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(section.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in section.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in section.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(section.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(section.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(section.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(section.Owner); + writer.WriteStartArray("page"u8); + + foreach(var pageItem in section.Page.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(pageItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(section.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(section.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Section for Version 1.2.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in section.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(section.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(section.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in section.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in section.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(section.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(section.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(section.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(section.Owner); + writer.WriteStartArray("page"u8); + + foreach(var pageItem in section.Page.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(pageItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(section.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(section.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(section.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Section for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(section.Actor.HasValue) + { + writer.WriteStringValue(section.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in section.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(section.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(section.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in section.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in section.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(section.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(section.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(section.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(section.Owner); + writer.WriteStartArray("page"u8); + + foreach(var pageItem in section.Page.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(pageItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(section.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(section.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(section.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SharedStyleSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SharedStyleSerializer.cs index 2ced7f76..c5318bfc 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SharedStyleSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SharedStyleSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,195 +50,597 @@ namespace CDP4JsonSerializer public class SharedStyleSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not SharedStyle sharedStyle) - { - throw new ArgumentException("The thing shall be a SharedStyle", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.1.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of SharedStyle since Version is below 1.1.0"); - return; - } + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - writer.WriteStartObject(); + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing SharedStyle for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(sharedStyle.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedDomainItem in sharedStyle.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + case "classkind": + var allowedVersionsForClassKind = new List { - writer.WriteStringValue(excludedDomainItem); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedPerson"u8); + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedPersonItem in sharedStyle.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteStringValue(excludedPersonItem); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; } + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } - writer.WritePropertyName("fillColor"u8); + writer.WriteEndArray(); + break; + case "fillcolor": + var allowedVersionsForFillColor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(sharedStyle.FillColor.HasValue) + if(!allowedVersionsForFillColor.Contains(requestedVersion)) { - writer.WriteStringValue(sharedStyle.FillColor.Value); + return; + } + + writer.WritePropertyName("fillColor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fillOpacity"u8); + break; + case "fillopacity": + var allowedVersionsForFillOpacity = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(sharedStyle.FillOpacity.HasValue) + if(!allowedVersionsForFillOpacity.Contains(requestedVersion)) { - writer.WriteNumberValue(sharedStyle.FillOpacity.Value); + return; + } + + writer.WritePropertyName("fillOpacity"u8); + + if(value != null) + { + writer.WriteNumberValue((float)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fontBold"u8); + break; + case "fontbold": + var allowedVersionsForFontBold = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(sharedStyle.FontBold.HasValue) + if(!allowedVersionsForFontBold.Contains(requestedVersion)) { - writer.WriteBooleanValue(sharedStyle.FontBold.Value); + return; + } + + writer.WritePropertyName("fontBold"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fontColor"u8); + break; + case "fontcolor": + var allowedVersionsForFontColor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(sharedStyle.FontColor.HasValue) + if(!allowedVersionsForFontColor.Contains(requestedVersion)) { - writer.WriteStringValue(sharedStyle.FontColor.Value); + return; + } + + writer.WritePropertyName("fontColor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fontItalic"u8); + break; + case "fontitalic": + var allowedVersionsForFontItalic = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(sharedStyle.FontItalic.HasValue) + if(!allowedVersionsForFontItalic.Contains(requestedVersion)) { - writer.WriteBooleanValue(sharedStyle.FontItalic.Value); + return; + } + + writer.WritePropertyName("fontItalic"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } + break; + case "fontname": + var allowedVersionsForFontName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFontName.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("fontName"u8); - writer.WriteStringValue(sharedStyle.FontName); - writer.WritePropertyName("fontSize"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - if(sharedStyle.FontSize.HasValue) + break; + case "fontsize": + var allowedVersionsForFontSize = new List { - writer.WriteNumberValue(sharedStyle.FontSize.Value); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForFontSize.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("fontSize"u8); + + if(value != null) + { + writer.WriteNumberValue((float)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fontStrokeThrough"u8); + break; + case "fontstrokethrough": + var allowedVersionsForFontStrokeThrough = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(sharedStyle.FontStrokeThrough.HasValue) + if(!allowedVersionsForFontStrokeThrough.Contains(requestedVersion)) { - writer.WriteBooleanValue(sharedStyle.FontStrokeThrough.Value); + return; + } + + writer.WritePropertyName("fontStrokeThrough"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("fontUnderline"u8); + break; + case "fontunderline": + var allowedVersionsForFontUnderline = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(sharedStyle.FontUnderline.HasValue) + if(!allowedVersionsForFontUnderline.Contains(requestedVersion)) { - writer.WriteBooleanValue(sharedStyle.FontUnderline.Value); + return; + } + + writer.WritePropertyName("fontUnderline"u8); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); } else { writer.WriteNullValue(); } + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("iid"u8); - writer.WriteStringValue(sharedStyle.Iid); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(sharedStyle.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "name": + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("name"u8); - writer.WriteStringValue(sharedStyle.Name); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(sharedStyle.RevisionNumber); - writer.WritePropertyName("strokeColor"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } - if(sharedStyle.StrokeColor.HasValue) + break; + case "strokecolor": + var allowedVersionsForStrokeColor = new List { - writer.WriteStringValue(sharedStyle.StrokeColor.Value); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStrokeColor.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("strokeColor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } + break; + case "strokeopacity": + var allowedVersionsForStrokeOpacity = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStrokeOpacity.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("strokeOpacity"u8); + + if(value != null) + { + writer.WriteNumberValue((float)value); + } + else + { + writer.WriteNullValue(); + } - if(sharedStyle.StrokeOpacity.HasValue) + break; + case "strokewidth": + var allowedVersionsForStrokeWidth = new List { - writer.WriteNumberValue(sharedStyle.StrokeOpacity.Value); + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStrokeWidth.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("strokeWidth"u8); + + if(value != null) + { + writer.WriteNumberValue((float)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("strokeWidth"u8); - - if(sharedStyle.StrokeWidth.HasValue) + break; + case "usedcolor": + var allowedVersionsForUsedColor = new List { - writer.WriteNumberValue(sharedStyle.StrokeWidth.Value); - } - else + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUsedColor.Contains(requestedVersion)) { - writer.WriteNullValue(); + return; } writer.WriteStartArray("usedColor"u8); - foreach(var usedColorItem in sharedStyle.UsedColor.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListUsedColor) { - writer.WriteStringValue(usedColorItem); + foreach(var usedColorItem in objectListUsedColor.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(usedColorItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SharedStyle for Version 1.2.0"); + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the SharedStyle"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not SharedStyle sharedStyle) + { + throw new ArgumentException("The thing shall be a SharedStyle", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SharedStyle since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing SharedStyle for Version 1.1.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(sharedStyle.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -250,7 +651,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in sharedStyle.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -259,7 +659,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("fillColor"u8); if(sharedStyle.FillColor.HasValue) @@ -391,8 +790,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNullValue(); } - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(sharedStyle.ThingPreference); writer.WriteStartArray("usedColor"u8); foreach(var usedColorItem in sharedStyle.UsedColor.OrderBy(x => x, this.GuidComparer)) @@ -401,21 +798,9 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SharedStyle for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(sharedStyle.Actor.HasValue) - { - writer.WriteStringValue(sharedStyle.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SharedStyle for Version 1.2.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(sharedStyle.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -426,7 +811,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in sharedStyle.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -435,7 +819,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("fillColor"u8); if(sharedStyle.FillColor.HasValue) @@ -506,529 +889,257 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WritePropertyName("fontStrokeThrough"u8); - if(sharedStyle.FontStrokeThrough.HasValue) - { - writer.WriteBooleanValue(sharedStyle.FontStrokeThrough.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("fontUnderline"u8); - - if(sharedStyle.FontUnderline.HasValue) - { - writer.WriteBooleanValue(sharedStyle.FontUnderline.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(sharedStyle.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(sharedStyle.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(sharedStyle.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(sharedStyle.RevisionNumber); - writer.WritePropertyName("strokeColor"u8); - - if(sharedStyle.StrokeColor.HasValue) - { - writer.WriteStringValue(sharedStyle.StrokeColor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("strokeOpacity"u8); - - if(sharedStyle.StrokeOpacity.HasValue) - { - writer.WriteNumberValue(sharedStyle.StrokeOpacity.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("strokeWidth"u8); - - if(sharedStyle.StrokeWidth.HasValue) - { - writer.WriteNumberValue(sharedStyle.StrokeWidth.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(sharedStyle.ThingPreference); - writer.WriteStartArray("usedColor"u8); - - foreach(var usedColorItem in sharedStyle.UsedColor.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(usedColorItem); - } - - writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "fillcolor": - if(!AllowedVersionsPerProperty["fillColor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("fillColor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "fillopacity": - if(!AllowedVersionsPerProperty["fillOpacity"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("fillOpacity"u8); - - if(value != null) + if(sharedStyle.FontStrokeThrough.HasValue) { - writer.WriteNumberValue((float)value); + writer.WriteBooleanValue(sharedStyle.FontStrokeThrough.Value); } else { writer.WriteNullValue(); } - break; - case "fontbold": - if(!AllowedVersionsPerProperty["fontBold"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontUnderline"u8); - writer.WritePropertyName("fontBold"u8); - - if(value != null) + if(sharedStyle.FontUnderline.HasValue) { - writer.WriteBooleanValue((bool)value); + writer.WriteBooleanValue(sharedStyle.FontUnderline.Value); } else { writer.WriteNullValue(); } - break; - case "fontcolor": - if(!AllowedVersionsPerProperty["fontColor"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(sharedStyle.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(sharedStyle.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(sharedStyle.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(sharedStyle.RevisionNumber); + writer.WritePropertyName("strokeColor"u8); - writer.WritePropertyName("fontColor"u8); - - if(value != null) + if(sharedStyle.StrokeColor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(sharedStyle.StrokeColor.Value); } else { writer.WriteNullValue(); } - break; - case "fontitalic": - if(!AllowedVersionsPerProperty["fontItalic"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("strokeOpacity"u8); - writer.WritePropertyName("fontItalic"u8); - - if(value != null) + if(sharedStyle.StrokeOpacity.HasValue) { - writer.WriteBooleanValue((bool)value); + writer.WriteNumberValue(sharedStyle.StrokeOpacity.Value); } else { writer.WriteNullValue(); } - break; - case "fontname": - if(!AllowedVersionsPerProperty["fontName"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("strokeWidth"u8); - writer.WritePropertyName("fontName"u8); - - if(value != null) + if(sharedStyle.StrokeWidth.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue(sharedStyle.StrokeWidth.Value); } else { writer.WriteNullValue(); } - break; - case "fontsize": - if(!AllowedVersionsPerProperty["fontSize"].Contains(requestedVersion)) + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(sharedStyle.ThingPreference); + writer.WriteStartArray("usedColor"u8); + + foreach(var usedColorItem in sharedStyle.UsedColor.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(usedColorItem); } - writer.WritePropertyName("fontSize"u8); - - if(value != null) + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SharedStyle for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(sharedStyle.Actor.HasValue) { - writer.WriteNumberValue((float)value); + writer.WriteStringValue(sharedStyle.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "fontstrokethrough": - if(!AllowedVersionsPerProperty["fontStrokeThrough"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(sharedStyle.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in sharedStyle.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("fontStrokeThrough"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in sharedStyle.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("fillColor"u8); + + if(sharedStyle.FillColor.HasValue) + { + writer.WriteStringValue(sharedStyle.FillColor.Value); } else { writer.WriteNullValue(); } - break; - case "fontunderline": - if(!AllowedVersionsPerProperty["fontUnderline"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fillOpacity"u8); - writer.WritePropertyName("fontUnderline"u8); - - if(value != null) + if(sharedStyle.FillOpacity.HasValue) { - writer.WriteBooleanValue((bool)value); + writer.WriteNumberValue(sharedStyle.FillOpacity.Value); } else { writer.WriteNullValue(); } - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontBold"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + if(sharedStyle.FontBold.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteBooleanValue(sharedStyle.FontBold.Value); } else { writer.WriteNullValue(); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontColor"u8); - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + if(sharedStyle.FontColor.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(sharedStyle.FontColor.Value); } else { writer.WriteNullValue(); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontItalic"u8); - writer.WritePropertyName("name"u8); - - if(value != null) + if(sharedStyle.FontItalic.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteBooleanValue(sharedStyle.FontItalic.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontName"u8); + writer.WriteStringValue(sharedStyle.FontName); + writer.WritePropertyName("fontSize"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(sharedStyle.FontSize.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteNumberValue(sharedStyle.FontSize.Value); } else { writer.WriteNullValue(); } - break; - case "strokecolor": - if(!AllowedVersionsPerProperty["strokeColor"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontStrokeThrough"u8); - writer.WritePropertyName("strokeColor"u8); - - if(value != null) + if(sharedStyle.FontStrokeThrough.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteBooleanValue(sharedStyle.FontStrokeThrough.Value); } else { writer.WriteNullValue(); } - break; - case "strokeopacity": - if(!AllowedVersionsPerProperty["strokeOpacity"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("fontUnderline"u8); - writer.WritePropertyName("strokeOpacity"u8); - - if(value != null) + if(sharedStyle.FontUnderline.HasValue) { - writer.WriteNumberValue((float)value); + writer.WriteBooleanValue(sharedStyle.FontUnderline.Value); } else { writer.WriteNullValue(); } - break; - case "strokewidth": - if(!AllowedVersionsPerProperty["strokeWidth"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(sharedStyle.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(sharedStyle.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(sharedStyle.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(sharedStyle.RevisionNumber); + writer.WritePropertyName("strokeColor"u8); - writer.WritePropertyName("strokeWidth"u8); - - if(value != null) + if(sharedStyle.StrokeColor.HasValue) { - writer.WriteNumberValue((float)value); + writer.WriteStringValue(sharedStyle.StrokeColor.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("strokeOpacity"u8); - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + if(sharedStyle.StrokeOpacity.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue(sharedStyle.StrokeOpacity.Value); } else { writer.WriteNullValue(); } - break; - case "usedcolor": - if(!AllowedVersionsPerProperty["usedColor"].Contains(requestedVersion)) + writer.WritePropertyName("strokeWidth"u8); + + if(sharedStyle.StrokeWidth.HasValue) { - return; + writer.WriteNumberValue(sharedStyle.StrokeWidth.Value); + } + else + { + writer.WriteNullValue(); } + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(sharedStyle.ThingPreference); writer.WriteStartArray("usedColor"u8); - if(value is IEnumerable objectListUsedColor) + foreach(var usedColorItem in sharedStyle.UsedColor.OrderBy(x => x, this.GuidComparer)) { - foreach(var usedColorItem in objectListUsedColor.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(usedColorItem); - } + writer.WriteStringValue(usedColorItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the SharedStyle"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fillColor", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fillOpacity", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontBold", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontColor", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontItalic", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontSize", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontStrokeThrough", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fontUnderline", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "strokeColor", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "strokeOpacity", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "strokeWidth", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "usedColor", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleParameterValueSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleParameterValueSerializer.cs index 4abe7173..f8aae430 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleParameterValueSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleParameterValueSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,205 +49,6 @@ namespace CDP4JsonSerializer /// public class SimpleParameterValueSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not SimpleParameterValue simpleParameterValue) - { - throw new ArgumentException("The thing shall be a SimpleParameterValue", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of SimpleParameterValue since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleParameterValue for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(simpleParameterValue.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(simpleParameterValue.Iid); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(simpleParameterValue.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(simpleParameterValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(simpleParameterValue.Scale.HasValue) - { - writer.WriteStringValue(simpleParameterValue.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteString("value"u8, simpleParameterValue.Value.ToJsonString()); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleParameterValue for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(simpleParameterValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in simpleParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in simpleParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(simpleParameterValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(simpleParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(simpleParameterValue.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(simpleParameterValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(simpleParameterValue.Scale.HasValue) - { - writer.WriteStringValue(simpleParameterValue.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteString("value"u8, simpleParameterValue.Value.ToJsonString()); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleParameterValue for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(simpleParameterValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in simpleParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in simpleParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(simpleParameterValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(simpleParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(simpleParameterValue.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(simpleParameterValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(simpleParameterValue.Scale.HasValue) - { - writer.WriteStringValue(simpleParameterValue.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(simpleParameterValue.ThingPreference); - writer.WriteString("value"u8, simpleParameterValue.Value.ToJsonString()); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleParameterValue for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(simpleParameterValue.Actor.HasValue) - { - writer.WriteStringValue(simpleParameterValue.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(simpleParameterValue.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in simpleParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in simpleParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(simpleParameterValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(simpleParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("parameterType"u8); - writer.WriteStringValue(simpleParameterValue.ParameterType); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(simpleParameterValue.RevisionNumber); - writer.WritePropertyName("scale"u8); - - if(simpleParameterValue.Scale.HasValue) - { - writer.WriteStringValue(simpleParameterValue.Scale.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(simpleParameterValue.ThingPreference); - writer.WriteString("value"u8, simpleParameterValue.Value.ToJsonString()); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -256,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -264,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -282,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -300,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -318,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -336,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -354,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -372,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + var allowedVersionsForParameterType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForParameterType.Contains(requestedVersion)) { return; } @@ -390,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -408,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "scale": - if(!AllowedVersionsPerProperty["scale"].Contains(requestedVersion)) + var allowedVersionsForScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForScale.Contains(requestedVersion)) { return; } @@ -426,7 +291,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -444,7 +315,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "value": - if(!AllowedVersionsPerProperty["value"].Contains(requestedVersion)) + var allowedVersionsForValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValue.Contains(requestedVersion)) { return; } @@ -457,22 +336,197 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "scale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "value", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not SimpleParameterValue simpleParameterValue) + { + throw new ArgumentException("The thing shall be a SimpleParameterValue", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SimpleParameterValue since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleParameterValue for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(simpleParameterValue.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(simpleParameterValue.Iid); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(simpleParameterValue.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(simpleParameterValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(simpleParameterValue.Scale.HasValue) + { + writer.WriteStringValue(simpleParameterValue.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteString("value"u8, simpleParameterValue.Value.ToJsonString()); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleParameterValue for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(simpleParameterValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in simpleParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in simpleParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(simpleParameterValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(simpleParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(simpleParameterValue.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(simpleParameterValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(simpleParameterValue.Scale.HasValue) + { + writer.WriteStringValue(simpleParameterValue.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteString("value"u8, simpleParameterValue.Value.ToJsonString()); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleParameterValue for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(simpleParameterValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in simpleParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in simpleParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(simpleParameterValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(simpleParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(simpleParameterValue.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(simpleParameterValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(simpleParameterValue.Scale.HasValue) + { + writer.WriteStringValue(simpleParameterValue.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(simpleParameterValue.ThingPreference); + writer.WriteString("value"u8, simpleParameterValue.Value.ToJsonString()); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleParameterValue for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(simpleParameterValue.Actor.HasValue) + { + writer.WriteStringValue(simpleParameterValue.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(simpleParameterValue.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in simpleParameterValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in simpleParameterValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(simpleParameterValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(simpleParameterValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("parameterType"u8); + writer.WriteStringValue(simpleParameterValue.ParameterType); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(simpleParameterValue.RevisionNumber); + writer.WritePropertyName("scale"u8); + + if(simpleParameterValue.Scale.HasValue) + { + writer.WriteStringValue(simpleParameterValue.Scale.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(simpleParameterValue.ThingPreference); + writer.WriteString("value"u8, simpleParameterValue.Value.ToJsonString()); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleQuantityKindSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleQuantityKindSerializer.cs index 0381206b..d1564944 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleQuantityKindSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleQuantityKindSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,401 +50,343 @@ namespace CDP4JsonSerializer public class SimpleQuantityKindSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not SimpleQuantityKind simpleQuantityKind) - { - throw new ArgumentException("The thing shall be a SimpleQuantityKind", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of SimpleQuantityKind since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleQuantityKind for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in simpleQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in simpleQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(simpleQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(simpleQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in simpleQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in simpleQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(simpleQuantityKind.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(simpleQuantityKind.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(simpleQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); + writer.WriteStartArray("alias"u8); - foreach(var possibleScaleItem in simpleQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(possibleScaleItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(simpleQuantityKind.QuantityDimensionSymbol); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(simpleQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(simpleQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(simpleQuantityKind.Symbol); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleQuantityKind for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in simpleQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in simpleQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(simpleQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(simpleQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in simpleQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in simpleQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in simpleQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "defaultscale": + var allowedVersionsForDefaultScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in simpleQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefaultScale.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("defaultScale"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(simpleQuantityKind.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(simpleQuantityKind.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(simpleQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(simpleQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); - - foreach(var possibleScaleItem in simpleQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(possibleScaleItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(simpleQuantityKind.QuantityDimensionSymbol); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(simpleQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(simpleQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(simpleQuantityKind.Symbol); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleQuantityKind for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in simpleQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("definition"u8); - foreach(var categoryItem in simpleQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(categoryItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(simpleQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(simpleQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in simpleQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); - foreach(var excludedDomainItem in simpleQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in simpleQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var hyperLinkItem in simpleQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(hyperLinkItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(simpleQuantityKind.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(simpleQuantityKind.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(simpleQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(simpleQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var possibleScaleItem in simpleQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(possibleScaleItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(simpleQuantityKind.QuantityDimensionSymbol); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(simpleQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(simpleQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(simpleQuantityKind.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(simpleQuantityKind.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleQuantityKind for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(simpleQuantityKind.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(simpleQuantityKind.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in simpleQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in simpleQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(simpleQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(simpleQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in simpleQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in simpleQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in simpleQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in simpleQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(hyperLinkItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(simpleQuantityKind.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(simpleQuantityKind.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(simpleQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(simpleQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); - - foreach(var possibleScaleItem in simpleQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(possibleScaleItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(simpleQuantityKind.QuantityDimensionSymbol); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(simpleQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(simpleQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(simpleQuantityKind.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(simpleQuantityKind.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -453,53 +394,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "possiblescale": + var allowedVersionsForPossibleScale = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(!allowedVersionsForPossibleScale.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("possibleScale"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListPossibleScale) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var possibleScaleItem in objectListPossibleScale.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(possibleScaleItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "quantitydimensionsymbol": + var allowedVersionsForQuantityDimensionSymbol = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForQuantityDimensionSymbol.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("quantityDimensionSymbol"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -507,17 +446,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "defaultscale": - if(!AllowedVersionsPerProperty["defaultScale"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("defaultScale"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -525,89 +472,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List { - return; - } - - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "symbol": + var allowedVersionsForSymbol = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("symbol"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -615,17 +524,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isDeprecated"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -633,180 +548,355 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the SimpleQuantityKind"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not SimpleQuantityKind simpleQuantityKind) + { + throw new ArgumentException("The thing shall be a SimpleQuantityKind", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SimpleQuantityKind since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleQuantityKind for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in simpleQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in simpleQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(simpleQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(simpleQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in simpleQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in simpleQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(simpleQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(simpleQuantityKind.IsDeprecated); writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteStringValue(simpleQuantityKind.Name); + writer.WriteStartArray("possibleScale"u8); + + foreach(var possibleScaleItem in simpleQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(possibleScaleItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(simpleQuantityKind.QuantityDimensionSymbol); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(simpleQuantityKind.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(simpleQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(simpleQuantityKind.Symbol); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleQuantityKind for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in simpleQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(aliasItem); } - break; - case "possiblescale": - if(!AllowedVersionsPerProperty["possibleScale"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in simpleQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(simpleQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(simpleQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in simpleQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in simpleQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in simpleQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in simpleQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(simpleQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(simpleQuantityKind.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(simpleQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(simpleQuantityKind.Name); writer.WriteStartArray("possibleScale"u8); - if(value is IEnumerable objectListPossibleScale) + foreach(var possibleScaleItem in simpleQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) { - foreach(var possibleScaleItem in objectListPossibleScale.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(possibleScaleItem); - } + writer.WriteStringValue(possibleScaleItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(simpleQuantityKind.QuantityDimensionSymbol); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(simpleQuantityKind.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(simpleQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(simpleQuantityKind.Symbol); break; - case "quantitydimensionsymbol": - if(!AllowedVersionsPerProperty["quantityDimensionSymbol"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleQuantityKind for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in simpleQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("quantityDimensionSymbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in simpleQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(simpleQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(simpleQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in simpleQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in simpleQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in simpleQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in simpleQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(simpleQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(simpleQuantityKind.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(simpleQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(simpleQuantityKind.Name); + writer.WriteStartArray("possibleScale"u8); + + foreach(var possibleScaleItem in simpleQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(possibleScaleItem); } + writer.WriteEndArray(); + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(simpleQuantityKind.QuantityDimensionSymbol); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(simpleQuantityKind.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(simpleQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(simpleQuantityKind.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(simpleQuantityKind.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleQuantityKind for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(simpleQuantityKind.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(simpleQuantityKind.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in simpleQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("symbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in simpleQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(simpleQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(simpleQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in simpleQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in simpleQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in simpleQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in simpleQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(simpleQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(simpleQuantityKind.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(simpleQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(simpleQuantityKind.Name); + writer.WriteStartArray("possibleScale"u8); + + foreach(var possibleScaleItem in simpleQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(possibleScaleItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(simpleQuantityKind.QuantityDimensionSymbol); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(simpleQuantityKind.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(simpleQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(simpleQuantityKind.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(simpleQuantityKind.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the SimpleQuantityKind"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "defaultScale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "possibleScale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "quantityDimensionSymbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleUnitSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleUnitSerializer.cs index 95afddc3..37ce4c2b 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleUnitSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SimpleUnitSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,112 +50,424 @@ namespace CDP4JsonSerializer public class SimpleUnitSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not SimpleUnit simpleUnit) - { - throw new ArgumentException("The thing shall be a SimpleUnit", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.0.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of SimpleUnit since Version is below 1.0.0"); - return; - } + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - writer.WriteStartObject(); + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleUnit for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var aliasItem in simpleUnit.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "alias": + var allowedVersionsForAlias = new List { - writer.WriteStringValue(aliasItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WriteStartArray("alias"u8); + + if(value is IEnumerable objectListAlias) + { + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + } + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(simpleUnit.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } - foreach(var definitionItem in simpleUnit.Definition.OrderBy(x => x, this.GuidComparer)) + break; + case "definition": + var allowedVersionsForDefinition = new List { - writer.WriteStringValue(definitionItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefinition.Contains(requestedVersion)) + { + return; } + writer.WriteStartArray("definition"u8); + + if(value is IEnumerable objectListDefinition) + { + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + } + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in simpleUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("iid"u8); - writer.WriteStringValue(simpleUnit.Iid); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(simpleUnit.IsDeprecated); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("name"u8); - writer.WriteStringValue(simpleUnit.Name); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(simpleUnit.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(simpleUnit.ShortName); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleUnit for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in simpleUnit.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(simpleUnit.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var definitionItem in simpleUnit.Definition.OrderBy(x => x, this.GuidComparer)) + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List { - writer.WriteStringValue(definitionItem); + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); - writer.WriteStartArray("excludedDomain"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedDomainItem in simpleUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the SimpleUnit"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not SimpleUnit simpleUnit) + { + throw new ArgumentException("The thing shall be a SimpleUnit", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SimpleUnit since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleUnit for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in simpleUnit.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(aliasItem); } writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(simpleUnit.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - foreach(var excludedPersonItem in simpleUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + foreach(var definitionItem in simpleUnit.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(definitionItem); } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in simpleUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -165,13 +476,10 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(simpleUnit.Iid); writer.WritePropertyName("isDeprecated"u8); writer.WriteBooleanValue(simpleUnit.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(simpleUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); writer.WriteStringValue(simpleUnit.Name); writer.WritePropertyName("revisionNumber"u8); @@ -179,8 +487,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WritePropertyName("shortName"u8); writer.WriteStringValue(simpleUnit.ShortName); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleUnit for Version 1.2.0"); + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleUnit for Version 1.1.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in simpleUnit.Alias.OrderBy(x => x, this.GuidComparer)) @@ -189,7 +497,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(simpleUnit.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -200,7 +507,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in simpleUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -209,7 +515,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in simpleUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -218,7 +523,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in simpleUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -227,7 +531,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(simpleUnit.Iid); writer.WritePropertyName("isDeprecated"u8); @@ -240,22 +543,9 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNumberValue(simpleUnit.RevisionNumber); writer.WritePropertyName("shortName"u8); writer.WriteStringValue(simpleUnit.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(simpleUnit.ThingPreference); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SimpleUnit for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(simpleUnit.Actor.HasValue) - { - writer.WriteStringValue(simpleUnit.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleUnit for Version 1.2.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in simpleUnit.Alias.OrderBy(x => x, this.GuidComparer)) @@ -264,7 +554,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(simpleUnit.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -275,7 +564,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in simpleUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -284,7 +572,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in simpleUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -293,7 +580,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in simpleUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -302,7 +588,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(simpleUnit.Iid); writer.WritePropertyName("isDeprecated"u8); @@ -318,304 +603,82 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WritePropertyName("thingPreference"u8); writer.WriteStringValue(simpleUnit.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SimpleUnit for Version 1.3.0"); writer.WritePropertyName("actor"u8); - - if(value != null) + + if(simpleUnit.Actor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(simpleUnit.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - writer.WriteStartArray("alias"u8); - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + foreach(var aliasItem in simpleUnit.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } + writer.WriteEndArray(); writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(simpleUnit.ClassKind.ToString()); writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + foreach(var definitionItem in simpleUnit.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + foreach(var excludedDomainItem in simpleUnit.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + foreach(var excludedPersonItem in simpleUnit.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + foreach(var hyperLinkItem in simpleUnit.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(simpleUnit.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - + writer.WriteBooleanValue(simpleUnit.IsDeprecated); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(simpleUnit.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(simpleUnit.Name); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } - + writer.WriteNumberValue(simpleUnit.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(simpleUnit.ShortName); writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - + writer.WriteStringValue(simpleUnit.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the SimpleUnit"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryDataAnnotationSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryDataAnnotationSerializer.cs index 727c1909..91fb72dd 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryDataAnnotationSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryDataAnnotationSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,224 +49,6 @@ namespace CDP4JsonSerializer /// public class SiteDirectoryDataAnnotationSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not SiteDirectoryDataAnnotation siteDirectoryDataAnnotation) - { - throw new ArgumentException("The thing shall be a SiteDirectoryDataAnnotation", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of SiteDirectoryDataAnnotation since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectoryDataAnnotation for Version 1.1.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in siteDirectoryDataAnnotation.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteDirectoryDataAnnotation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteDirectoryDataAnnotation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("primaryAnnotatedThing"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.PrimaryAnnotatedThing); - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in siteDirectoryDataAnnotation.RelatedThing.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectoryDataAnnotation.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectoryDataAnnotation for Version 1.2.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in siteDirectoryDataAnnotation.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteDirectoryDataAnnotation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteDirectoryDataAnnotation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("primaryAnnotatedThing"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.PrimaryAnnotatedThing); - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in siteDirectoryDataAnnotation.RelatedThing.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectoryDataAnnotation.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectoryDataAnnotation for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(siteDirectoryDataAnnotation.Actor.HasValue) - { - writer.WriteStringValue(siteDirectoryDataAnnotation.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("discussion"u8); - - foreach(var discussionItem in siteDirectoryDataAnnotation.Discussion.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(discussionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteDirectoryDataAnnotation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteDirectoryDataAnnotation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("primaryAnnotatedThing"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.PrimaryAnnotatedThing); - writer.WriteStartArray("relatedThing"u8); - - foreach(var relatedThingItem in siteDirectoryDataAnnotation.RelatedThing.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(relatedThingItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectoryDataAnnotation.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteDirectoryDataAnnotation.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -275,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -283,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -301,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { return; } @@ -319,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -337,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContent.Contains(requestedVersion)) { return; } @@ -355,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -373,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "discussion": - if(!AllowedVersionsPerProperty["discussion"].Contains(requestedVersion)) + var allowedVersionsForDiscussion = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDiscussion.Contains(requestedVersion)) { return; } @@ -391,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -409,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -427,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -445,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + var allowedVersionsForLanguageCode = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } @@ -463,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -481,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "primaryannotatedthing": - if(!AllowedVersionsPerProperty["primaryAnnotatedThing"].Contains(requestedVersion)) + var allowedVersionsForPrimaryAnnotatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPrimaryAnnotatedThing.Contains(requestedVersion)) { return; } @@ -499,7 +361,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "relatedthing": - if(!AllowedVersionsPerProperty["relatedThing"].Contains(requestedVersion)) + var allowedVersionsForRelatedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRelatedThing.Contains(requestedVersion)) { return; } @@ -517,7 +386,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -535,7 +411,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -558,26 +440,210 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "discussion", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "primaryAnnotatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "relatedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not SiteDirectoryDataAnnotation siteDirectoryDataAnnotation) + { + throw new ArgumentException("The thing shall be a SiteDirectoryDataAnnotation", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SiteDirectoryDataAnnotation since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectoryDataAnnotation for Version 1.1.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in siteDirectoryDataAnnotation.Discussion.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteDirectoryDataAnnotation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectoryDataAnnotation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("primaryAnnotatedThing"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.PrimaryAnnotatedThing); + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in siteDirectoryDataAnnotation.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectoryDataAnnotation.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectoryDataAnnotation for Version 1.2.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in siteDirectoryDataAnnotation.Discussion.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteDirectoryDataAnnotation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectoryDataAnnotation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("primaryAnnotatedThing"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.PrimaryAnnotatedThing); + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in siteDirectoryDataAnnotation.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectoryDataAnnotation.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectoryDataAnnotation for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(siteDirectoryDataAnnotation.Actor.HasValue) + { + writer.WriteStringValue(siteDirectoryDataAnnotation.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("author"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("discussion"u8); + + foreach(var discussionItem in siteDirectoryDataAnnotation.Discussion.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(discussionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteDirectoryDataAnnotation.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectoryDataAnnotation.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("primaryAnnotatedThing"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.PrimaryAnnotatedThing); + writer.WriteStartArray("relatedThing"u8); + + foreach(var relatedThingItem in siteDirectoryDataAnnotation.RelatedThing.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(relatedThingItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectoryDataAnnotation.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteDirectoryDataAnnotation.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryDataDiscussionItemSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryDataDiscussionItemSerializer.cs index 227f64e2..b04f9b5d 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryDataDiscussionItemSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryDataDiscussionItemSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,197 +49,6 @@ namespace CDP4JsonSerializer /// public class SiteDirectoryDataDiscussionItemSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not SiteDirectoryDataDiscussionItem siteDirectoryDataDiscussionItem) - { - throw new ArgumentException("The thing shall be a SiteDirectoryDataDiscussionItem", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of SiteDirectoryDataDiscussionItem since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectoryDataDiscussionItem for Version 1.1.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteDirectoryDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteDirectoryDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("replyTo"u8); - - if(siteDirectoryDataDiscussionItem.ReplyTo.HasValue) - { - writer.WriteStringValue(siteDirectoryDataDiscussionItem.ReplyTo.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectoryDataDiscussionItem.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectoryDataDiscussionItem for Version 1.2.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteDirectoryDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteDirectoryDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("replyTo"u8); - - if(siteDirectoryDataDiscussionItem.ReplyTo.HasValue) - { - writer.WriteStringValue(siteDirectoryDataDiscussionItem.ReplyTo.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectoryDataDiscussionItem.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectoryDataDiscussionItem for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(siteDirectoryDataDiscussionItem.Actor.HasValue) - { - writer.WriteStringValue(siteDirectoryDataDiscussionItem.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteDirectoryDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteDirectoryDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("replyTo"u8); - - if(siteDirectoryDataDiscussionItem.ReplyTo.HasValue) - { - writer.WriteStringValue(siteDirectoryDataDiscussionItem.ReplyTo.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectoryDataDiscussionItem.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteDirectoryDataDiscussionItem.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -248,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -256,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -274,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { return; } @@ -292,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -310,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContent.Contains(requestedVersion)) { return; } @@ -328,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -346,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -364,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -382,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -400,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + var allowedVersionsForLanguageCode = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } @@ -418,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -436,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "replyto": - if(!AllowedVersionsPerProperty["replyTo"].Contains(requestedVersion)) + var allowedVersionsForReplyTo = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReplyTo.Contains(requestedVersion)) { return; } @@ -454,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -472,7 +361,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -495,24 +390,189 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "replyTo", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not SiteDirectoryDataDiscussionItem siteDirectoryDataDiscussionItem) + { + throw new ArgumentException("The thing shall be a SiteDirectoryDataDiscussionItem", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SiteDirectoryDataDiscussionItem since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectoryDataDiscussionItem for Version 1.1.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteDirectoryDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectoryDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("replyTo"u8); + + if(siteDirectoryDataDiscussionItem.ReplyTo.HasValue) + { + writer.WriteStringValue(siteDirectoryDataDiscussionItem.ReplyTo.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectoryDataDiscussionItem.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectoryDataDiscussionItem for Version 1.2.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteDirectoryDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectoryDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("replyTo"u8); + + if(siteDirectoryDataDiscussionItem.ReplyTo.HasValue) + { + writer.WriteStringValue(siteDirectoryDataDiscussionItem.ReplyTo.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectoryDataDiscussionItem.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectoryDataDiscussionItem for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(siteDirectoryDataDiscussionItem.Actor.HasValue) + { + writer.WriteStringValue(siteDirectoryDataDiscussionItem.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("author"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteDirectoryDataDiscussionItem.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectoryDataDiscussionItem.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("replyTo"u8); + + if(siteDirectoryDataDiscussionItem.ReplyTo.HasValue) + { + writer.WriteStringValue(siteDirectoryDataDiscussionItem.ReplyTo.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectoryDataDiscussionItem.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteDirectoryDataDiscussionItem.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectorySerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectorySerializer.cs index 64dd0119..0b02b53b 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectorySerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectorySerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,499 +50,691 @@ namespace CDP4JsonSerializer public class SiteDirectorySerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not SiteDirectory siteDirectory) - { - throw new ArgumentException("The thing shall be a SiteDirectory", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of SiteDirectory since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectory for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectory.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteDirectory.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("defaultParticipantRole"u8); - - if(siteDirectory.DefaultParticipantRole.HasValue) + case "actor": + var allowedVersionsForActor = new List { - writer.WriteStringValue(siteDirectory.DefaultParticipantRole.Value); - } - else + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteNullValue(); + return; } - writer.WritePropertyName("defaultPersonRole"u8); - - if(siteDirectory.DefaultPersonRole.HasValue) + writer.WritePropertyName("actor"u8); + + if(value != null) { - writer.WriteStringValue(siteDirectory.DefaultPersonRole.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("domain"u8); + break; + case "annotation": + var allowedVersionsForAnnotation = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var domainItem in siteDirectory.Domain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAnnotation.Contains(requestedVersion)) { - writer.WriteStringValue(domainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("domainGroup"u8); + writer.WriteStartArray("annotation"u8); - foreach(var domainGroupItem in siteDirectory.DomainGroup.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAnnotation) { - writer.WriteStringValue(domainGroupItem); + foreach(var annotationItem in objectListAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(annotationItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectory.Iid); - writer.WritePropertyName("lastModifiedOn"u8); - writer.WriteStringValue(siteDirectory.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("logEntry"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var logEntryItem in siteDirectory.LogEntry.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(logEntryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("model"u8); - - foreach(var modelItem in siteDirectory.Model.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(modelItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WritePropertyName("name"u8); - writer.WriteStringValue(siteDirectory.Name); - writer.WriteStartArray("naturalLanguage"u8); - - foreach(var naturalLanguageItem in siteDirectory.NaturalLanguage.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(naturalLanguageItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("organization"u8); + break; + case "createdon": + var allowedVersionsForCreatedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var organizationItem in siteDirectory.Organization.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { - writer.WriteStringValue(organizationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("createdOn"u8); - writer.WriteStartArray("participantRole"u8); - - foreach(var participantRoleItem in siteDirectory.ParticipantRole.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(participantRoleItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WriteStartArray("person"u8); - - foreach(var personItem in siteDirectory.Person.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(personItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("personRole"u8); + break; + case "defaultparticipantrole": + var allowedVersionsForDefaultParticipantRole = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var personRoleItem in siteDirectory.PersonRole.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefaultParticipantRole.Contains(requestedVersion)) { - writer.WriteStringValue(personRoleItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("defaultParticipantRole"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectory.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(siteDirectory.ShortName); - writer.WriteStartArray("siteReferenceDataLibrary"u8); - - foreach(var siteReferenceDataLibraryItem in siteDirectory.SiteReferenceDataLibrary.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(siteReferenceDataLibraryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectory for Version 1.1.0"); - writer.WriteStartArray("annotation"u8); + case "defaultpersonrole": + var allowedVersionsForDefaultPersonRole = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var annotationItem in siteDirectory.Annotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefaultPersonRole.Contains(requestedVersion)) { - writer.WriteStringValue(annotationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("defaultPersonRole"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectory.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteDirectory.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("defaultParticipantRole"u8); - - if(siteDirectory.DefaultParticipantRole.HasValue) + if(value != null) { - writer.WriteStringValue(siteDirectory.DefaultParticipantRole.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("defaultPersonRole"u8); - - if(siteDirectory.DefaultPersonRole.HasValue) + break; + case "domain": + var allowedVersionsForDomain = new List { - writer.WriteStringValue(siteDirectory.DefaultPersonRole.Value); - } - else + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDomain.Contains(requestedVersion)) { - writer.WriteNullValue(); + return; } writer.WriteStartArray("domain"u8); - foreach(var domainItem in siteDirectory.Domain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDomain) { - writer.WriteStringValue(domainItem); + foreach(var domainItem in objectListDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("domainGroup"u8); + writer.WriteEndArray(); + break; + case "domaingroup": + var allowedVersionsForDomainGroup = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var domainGroupItem in siteDirectory.DomainGroup.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDomainGroup.Contains(requestedVersion)) { - writer.WriteStringValue(domainGroupItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("domainGroup"u8); - foreach(var excludedDomainItem in siteDirectory.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDomainGroup) { - writer.WriteStringValue(excludedDomainItem); + foreach(var domainGroupItem in objectListDomainGroup.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(domainGroupItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in siteDirectory.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectory.Iid); - writer.WritePropertyName("lastModifiedOn"u8); - writer.WriteStringValue(siteDirectory.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("logEntry"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var logEntryItem in siteDirectory.LogEntry.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(logEntryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("model"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var modelItem in siteDirectory.Model.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(modelItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectory.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(siteDirectory.Name); - writer.WriteStartArray("naturalLanguage"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var naturalLanguageItem in siteDirectory.NaturalLanguage.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(naturalLanguageItem); - } - - writer.WriteEndArray(); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } - writer.WriteStartArray("organization"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var organizationItem in siteDirectory.Organization.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(organizationItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WriteStartArray("participantRole"u8); - - foreach(var participantRoleItem in siteDirectory.ParticipantRole.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(participantRoleItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("person"u8); + break; + case "lastmodifiedon": + var allowedVersionsForLastModifiedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var personItem in siteDirectory.Person.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForLastModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(personItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("lastModifiedOn"u8); - writer.WriteStartArray("personRole"u8); - - foreach(var personRoleItem in siteDirectory.PersonRole.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(personRoleItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectory.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(siteDirectory.ShortName); - writer.WriteStartArray("siteReferenceDataLibrary"u8); + break; + case "logentry": + var allowedVersionsForLogEntry = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var siteReferenceDataLibraryItem in siteDirectory.SiteReferenceDataLibrary.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForLogEntry.Contains(requestedVersion)) { - writer.WriteStringValue(siteReferenceDataLibraryItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("logEntry"u8); + + if(value is IEnumerable objectListLogEntry) + { + foreach(var logEntryItem in objectListLogEntry.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(logEntryItem); + } + } + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectory for Version 1.2.0"); - writer.WriteStartArray("annotation"u8); + case "model": + var allowedVersionsForModel = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var annotationItem in siteDirectory.Annotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModel.Contains(requestedVersion)) { - writer.WriteStringValue(annotationItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectory.ClassKind.ToString()); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteDirectory.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("defaultParticipantRole"u8); + writer.WriteStartArray("model"u8); - if(siteDirectory.DefaultParticipantRole.HasValue) + if(value is IEnumerable objectListModel) { - writer.WriteStringValue(siteDirectory.DefaultParticipantRole.Value); + foreach(var modelItem in objectListModel.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(modelItem); + } } - else + + writer.WriteEndArray(); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List { - writer.WriteNullValue(); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WritePropertyName("defaultPersonRole"u8); + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } - if(siteDirectory.DefaultPersonRole.HasValue) + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) { - writer.WriteStringValue(siteDirectory.DefaultPersonRole.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("domain"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var domainItem in siteDirectory.Domain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(domainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WriteStartArray("domainGroup"u8); - - foreach(var domainGroupItem in siteDirectory.DomainGroup.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(domainGroupItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "naturallanguage": + var allowedVersionsForNaturalLanguage = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in siteDirectory.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForNaturalLanguage.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("naturalLanguage"u8); - foreach(var excludedPersonItem in siteDirectory.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListNaturalLanguage) { - writer.WriteStringValue(excludedPersonItem); + foreach(var naturalLanguageItem in objectListNaturalLanguage.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(naturalLanguageItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectory.Iid); - writer.WritePropertyName("lastModifiedOn"u8); - writer.WriteStringValue(siteDirectory.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("logEntry"u8); + writer.WriteEndArray(); + break; + case "organization": + var allowedVersionsForOrganization = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var logEntryItem in siteDirectory.LogEntry.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForOrganization.Contains(requestedVersion)) { - writer.WriteStringValue(logEntryItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("model"u8); + writer.WriteStartArray("organization"u8); - foreach(var modelItem in siteDirectory.Model.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListOrganization) { - writer.WriteStringValue(modelItem); + foreach(var organizationItem in objectListOrganization.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(organizationItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectory.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(siteDirectory.Name); - writer.WriteStartArray("naturalLanguage"u8); + writer.WriteEndArray(); + break; + case "participantrole": + var allowedVersionsForParticipantRole = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var naturalLanguageItem in siteDirectory.NaturalLanguage.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForParticipantRole.Contains(requestedVersion)) { - writer.WriteStringValue(naturalLanguageItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("organization"u8); + writer.WriteStartArray("participantRole"u8); - foreach(var organizationItem in siteDirectory.Organization.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListParticipantRole) { - writer.WriteStringValue(organizationItem); + foreach(var participantRoleItem in objectListParticipantRole.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(participantRoleItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("participantRole"u8); + writer.WriteEndArray(); + break; + case "person": + var allowedVersionsForPerson = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var participantRoleItem in siteDirectory.ParticipantRole.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForPerson.Contains(requestedVersion)) { - writer.WriteStringValue(participantRoleItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("person"u8); - foreach(var personItem in siteDirectory.Person.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListPerson) { - writer.WriteStringValue(personItem); + foreach(var personItem in objectListPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(personItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("personRole"u8); + writer.WriteEndArray(); + break; + case "personrole": + var allowedVersionsForPersonRole = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var personRoleItem in siteDirectory.PersonRole.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForPersonRole.Contains(requestedVersion)) { - writer.WriteStringValue(personRoleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectory.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(siteDirectory.ShortName); - writer.WriteStartArray("siteReferenceDataLibrary"u8); + writer.WriteStartArray("personRole"u8); - foreach(var siteReferenceDataLibraryItem in siteDirectory.SiteReferenceDataLibrary.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListPersonRole) { - writer.WriteStringValue(siteReferenceDataLibraryItem); + foreach(var personRoleItem in objectListPersonRole.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(personRoleItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteDirectory.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectory for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(siteDirectory.Actor.HasValue) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - writer.WriteStringValue(siteDirectory.Actor.Value); + return; + } + + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("annotation"u8); + break; + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var annotationItem in siteDirectory.Annotation.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { - writer.WriteStringValue(annotationItem); + return; + } + + writer.WritePropertyName("shortName"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "sitereferencedatalibrary": + var allowedVersionsForSiteReferenceDataLibrary = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSiteReferenceDataLibrary.Contains(requestedVersion)) + { + return; } + writer.WriteStartArray("siteReferenceDataLibrary"u8); + + if(value is IEnumerable objectListSiteReferenceDataLibrary) + { + foreach(var siteReferenceDataLibraryItem in objectListSiteReferenceDataLibrary.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(siteReferenceDataLibraryItem); + } + } + writer.WriteEndArray(); + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the SiteDirectory"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not SiteDirectory siteDirectory) + { + throw new ArgumentException("The thing shall be a SiteDirectory", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SiteDirectory since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectory for Version 1.0.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(siteDirectory.ClassKind.ToString()); writer.WritePropertyName("createdOn"u8); @@ -578,7 +769,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("domainGroup"u8); foreach(var domainGroupItem in siteDirectory.DomainGroup.OrderBy(x => x, this.GuidComparer)) @@ -587,25 +777,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteDirectory.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteDirectory.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(siteDirectory.Iid); writer.WritePropertyName("lastModifiedOn"u8); @@ -618,7 +789,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("model"u8); foreach(var modelItem in siteDirectory.Model.OrderBy(x => x, this.GuidComparer)) @@ -627,9 +797,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectory.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); writer.WriteStringValue(siteDirectory.Name); writer.WriteStartArray("naturalLanguage"u8); @@ -640,7 +807,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("organization"u8); foreach(var organizationItem in siteDirectory.Organization.OrderBy(x => x, this.GuidComparer)) @@ -649,7 +815,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("participantRole"u8); foreach(var participantRoleItem in siteDirectory.ParticipantRole.OrderBy(x => x, this.GuidComparer)) @@ -658,7 +823,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("person"u8); foreach(var personItem in siteDirectory.Person.OrderBy(x => x, this.GuidComparer)) @@ -667,7 +831,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("personRole"u8); foreach(var personRoleItem in siteDirectory.PersonRole.OrderBy(x => x, this.GuidComparer)) @@ -676,7 +839,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); writer.WriteNumberValue(siteDirectory.RevisionNumber); writer.WritePropertyName("shortName"u8); @@ -689,517 +851,463 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteDirectory.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectory for Version 1.1.0"); + writer.WriteStartArray("annotation"u8); - writer.WriteEndObject(); - } + foreach(var annotationItem in siteDirectory.Annotation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(annotationItem); + } - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectory.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteDirectory.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("defaultParticipantRole"u8); - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(siteDirectory.DefaultParticipantRole.HasValue) { - return; + writer.WriteStringValue(siteDirectory.DefaultParticipantRole.Value); + } + else + { + writer.WriteNullValue(); } - writer.WritePropertyName("actor"u8); - - if(value != null) + writer.WritePropertyName("defaultPersonRole"u8); + + if(siteDirectory.DefaultPersonRole.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(siteDirectory.DefaultPersonRole.Value); } else { writer.WriteNullValue(); } - break; - case "annotation": - if(!AllowedVersionsPerProperty["annotation"].Contains(requestedVersion)) + writer.WriteStartArray("domain"u8); + + foreach(var domainItem in siteDirectory.Domain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(domainItem); } - writer.WriteStartArray("annotation"u8); + writer.WriteEndArray(); + writer.WriteStartArray("domainGroup"u8); - if(value is IEnumerable objectListAnnotation) + foreach(var domainGroupItem in siteDirectory.DomainGroup.OrderBy(x => x, this.GuidComparer)) { - foreach(var annotationItem in objectListAnnotation.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(annotationItem); - } + writer.WriteStringValue(domainGroupItem); } - + writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteDirectory.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("classKind"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectory.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteDirectory.Iid); + writer.WritePropertyName("lastModifiedOn"u8); + writer.WriteStringValue(siteDirectory.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("logEntry"u8); + + foreach(var logEntryItem in siteDirectory.LogEntry.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(logEntryItem); } - break; - case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("model"u8); + + foreach(var modelItem in siteDirectory.Model.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(modelItem); } - writer.WritePropertyName("createdOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectory.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(siteDirectory.Name); + writer.WriteStartArray("naturalLanguage"u8); + + foreach(var naturalLanguageItem in siteDirectory.NaturalLanguage.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(naturalLanguageItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("organization"u8); + + foreach(var organizationItem in siteDirectory.Organization.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(organizationItem); } - break; - case "defaultparticipantrole": - if(!AllowedVersionsPerProperty["defaultParticipantRole"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("participantRole"u8); + + foreach(var participantRoleItem in siteDirectory.ParticipantRole.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(participantRoleItem); } - writer.WritePropertyName("defaultParticipantRole"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } + writer.WriteEndArray(); + writer.WriteStartArray("person"u8); - break; - case "defaultpersonrole": - if(!AllowedVersionsPerProperty["defaultPersonRole"].Contains(requestedVersion)) + foreach(var personItem in siteDirectory.Person.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(personItem); } - writer.WritePropertyName("defaultPersonRole"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("personRole"u8); + + foreach(var personRoleItem in siteDirectory.PersonRole.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(personRoleItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectory.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(siteDirectory.ShortName); + writer.WriteStartArray("siteReferenceDataLibrary"u8); + + foreach(var siteReferenceDataLibraryItem in siteDirectory.SiteReferenceDataLibrary.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(siteReferenceDataLibraryItem); } + writer.WriteEndArray(); break; - case "domain": - if(!AllowedVersionsPerProperty["domain"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectory for Version 1.2.0"); + writer.WriteStartArray("annotation"u8); + + foreach(var annotationItem in siteDirectory.Annotation.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(annotationItem); } - writer.WriteStartArray("domain"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectory.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteDirectory.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("defaultParticipantRole"u8); - if(value is IEnumerable objectListDomain) + if(siteDirectory.DefaultParticipantRole.HasValue) { - foreach(var domainItem in objectListDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainItem); - } + writer.WriteStringValue(siteDirectory.DefaultParticipantRole.Value); } - - writer.WriteEndArray(); - break; - case "domaingroup": - if(!AllowedVersionsPerProperty["domainGroup"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("domainGroup"u8); + writer.WritePropertyName("defaultPersonRole"u8); - if(value is IEnumerable objectListDomainGroup) + if(siteDirectory.DefaultPersonRole.HasValue) { - foreach(var domainGroupItem in objectListDomainGroup.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(domainGroupItem); - } + writer.WriteStringValue(siteDirectory.DefaultPersonRole.Value); } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("domain"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var domainItem in siteDirectory.Domain.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(domainItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WriteStartArray("domainGroup"u8); + + foreach(var domainGroupItem in siteDirectory.DomainGroup.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(domainGroupItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var excludedDomainItem in siteDirectory.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectory.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else + writer.WriteStringValue(siteDirectory.Iid); + writer.WritePropertyName("lastModifiedOn"u8); + writer.WriteStringValue(siteDirectory.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("logEntry"u8); + + foreach(var logEntryItem in siteDirectory.LogEntry.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(logEntryItem); } - break; - case "lastmodifiedon": - if(!AllowedVersionsPerProperty["lastModifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("model"u8); + + foreach(var modelItem in siteDirectory.Model.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(modelItem); } - writer.WritePropertyName("lastModifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectory.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(siteDirectory.Name); + writer.WriteStartArray("naturalLanguage"u8); + + foreach(var naturalLanguageItem in siteDirectory.NaturalLanguage.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(naturalLanguageItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("organization"u8); + + foreach(var organizationItem in siteDirectory.Organization.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(organizationItem); } - break; - case "logentry": - if(!AllowedVersionsPerProperty["logEntry"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("participantRole"u8); + + foreach(var participantRoleItem in siteDirectory.ParticipantRole.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(participantRoleItem); } - writer.WriteStartArray("logEntry"u8); + writer.WriteEndArray(); + writer.WriteStartArray("person"u8); - if(value is IEnumerable objectListLogEntry) + foreach(var personItem in siteDirectory.Person.OrderBy(x => x, this.GuidComparer)) { - foreach(var logEntryItem in objectListLogEntry.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(logEntryItem); - } + writer.WriteStringValue(personItem); } - + writer.WriteEndArray(); - break; - case "model": - if(!AllowedVersionsPerProperty["model"].Contains(requestedVersion)) + writer.WriteStartArray("personRole"u8); + + foreach(var personRoleItem in siteDirectory.PersonRole.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(personRoleItem); } - writer.WriteStartArray("model"u8); + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectory.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(siteDirectory.ShortName); + writer.WriteStartArray("siteReferenceDataLibrary"u8); - if(value is IEnumerable objectListModel) + foreach(var siteReferenceDataLibraryItem in siteDirectory.SiteReferenceDataLibrary.OrderBy(x => x, this.GuidComparer)) { - foreach(var modelItem in objectListModel.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(modelItem); - } + writer.WriteStringValue(siteReferenceDataLibraryItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteDirectory.ThingPreference); break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectory for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + if(siteDirectory.Actor.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(siteDirectory.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteStartArray("annotation"u8); + + foreach(var annotationItem in siteDirectory.Annotation.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(annotationItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectory.ClassKind.ToString()); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteDirectory.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("defaultParticipantRole"u8); + + if(siteDirectory.DefaultParticipantRole.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(siteDirectory.DefaultParticipantRole.Value); } else { writer.WriteNullValue(); } - break; - case "naturallanguage": - if(!AllowedVersionsPerProperty["naturalLanguage"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("naturalLanguage"u8); + writer.WritePropertyName("defaultPersonRole"u8); - if(value is IEnumerable objectListNaturalLanguage) + if(siteDirectory.DefaultPersonRole.HasValue) { - foreach(var naturalLanguageItem in objectListNaturalLanguage.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(naturalLanguageItem); - } + writer.WriteStringValue(siteDirectory.DefaultPersonRole.Value); } - - writer.WriteEndArray(); - break; - case "organization": - if(!AllowedVersionsPerProperty["organization"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("organization"u8); + writer.WriteStartArray("domain"u8); - if(value is IEnumerable objectListOrganization) + foreach(var domainItem in siteDirectory.Domain.OrderBy(x => x, this.GuidComparer)) { - foreach(var organizationItem in objectListOrganization.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(organizationItem); - } + writer.WriteStringValue(domainItem); } - + writer.WriteEndArray(); - break; - case "participantrole": - if(!AllowedVersionsPerProperty["participantRole"].Contains(requestedVersion)) + writer.WriteStartArray("domainGroup"u8); + + foreach(var domainGroupItem in siteDirectory.DomainGroup.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(domainGroupItem); } - writer.WriteStartArray("participantRole"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListParticipantRole) + foreach(var excludedDomainItem in siteDirectory.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var participantRoleItem in objectListParticipantRole.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(participantRoleItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "person": - if(!AllowedVersionsPerProperty["person"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectory.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WriteStartArray("person"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteDirectory.Iid); + writer.WritePropertyName("lastModifiedOn"u8); + writer.WriteStringValue(siteDirectory.LastModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("logEntry"u8); - if(value is IEnumerable objectListPerson) + foreach(var logEntryItem in siteDirectory.LogEntry.OrderBy(x => x, this.GuidComparer)) { - foreach(var personItem in objectListPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(personItem); - } + writer.WriteStringValue(logEntryItem); } - + writer.WriteEndArray(); - break; - case "personrole": - if(!AllowedVersionsPerProperty["personRole"].Contains(requestedVersion)) + writer.WriteStartArray("model"u8); + + foreach(var modelItem in siteDirectory.Model.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(modelItem); } - writer.WriteStartArray("personRole"u8); + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectory.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(siteDirectory.Name); + writer.WriteStartArray("naturalLanguage"u8); - if(value is IEnumerable objectListPersonRole) + foreach(var naturalLanguageItem in siteDirectory.NaturalLanguage.OrderBy(x => x, this.GuidComparer)) { - foreach(var personRoleItem in objectListPersonRole.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(personRoleItem); - } + writer.WriteStringValue(naturalLanguageItem); } - + writer.WriteEndArray(); - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("organization"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else + foreach(var organizationItem in siteDirectory.Organization.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(organizationItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WriteEndArray(); + writer.WriteStartArray("participantRole"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else + foreach(var participantRoleItem in siteDirectory.ParticipantRole.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(participantRoleItem); } - break; - case "sitereferencedatalibrary": - if(!AllowedVersionsPerProperty["siteReferenceDataLibrary"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("person"u8); + + foreach(var personItem in siteDirectory.Person.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(personItem); } - writer.WriteStartArray("siteReferenceDataLibrary"u8); + writer.WriteEndArray(); + writer.WriteStartArray("personRole"u8); - if(value is IEnumerable objectListSiteReferenceDataLibrary) + foreach(var personRoleItem in siteDirectory.PersonRole.OrderBy(x => x, this.GuidComparer)) { - foreach(var siteReferenceDataLibraryItem in objectListSiteReferenceDataLibrary.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(siteReferenceDataLibraryItem); - } + writer.WriteStringValue(personRoleItem); } - + writer.WriteEndArray(); - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectory.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(siteDirectory.ShortName); + writer.WriteStartArray("siteReferenceDataLibrary"u8); - writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else + foreach(var siteReferenceDataLibraryItem in siteDirectory.SiteReferenceDataLibrary.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(siteReferenceDataLibraryItem); } + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteDirectory.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the SiteDirectory"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "annotation", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "defaultParticipantRole", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "defaultPersonRole", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "domain", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "domainGroup", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "lastModifiedOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "logEntry", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "model", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "naturalLanguage", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "organization", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "participantRole", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "person", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "personRole", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "siteReferenceDataLibrary", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryThingReferenceSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryThingReferenceSerializer.cs index 4600c357..22b0c231 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryThingReferenceSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteDirectoryThingReferenceSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,152 +49,6 @@ namespace CDP4JsonSerializer /// public class SiteDirectoryThingReferenceSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not SiteDirectoryThingReference siteDirectoryThingReference) - { - throw new ArgumentException("The thing shall be a SiteDirectoryThingReference", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of SiteDirectoryThingReference since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectoryThingReference for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectoryThingReference.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteDirectoryThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteDirectoryThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectoryThingReference.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectoryThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("referencedRevisionNumber"u8); - writer.WriteNumberValue(siteDirectoryThingReference.ReferencedRevisionNumber); - writer.WritePropertyName("referencedThing"u8); - writer.WriteStringValue(siteDirectoryThingReference.ReferencedThing); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectoryThingReference.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectoryThingReference for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectoryThingReference.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteDirectoryThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteDirectoryThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectoryThingReference.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectoryThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("referencedRevisionNumber"u8); - writer.WriteNumberValue(siteDirectoryThingReference.ReferencedRevisionNumber); - writer.WritePropertyName("referencedThing"u8); - writer.WriteStringValue(siteDirectoryThingReference.ReferencedThing); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectoryThingReference.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteDirectoryThingReference.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SiteDirectoryThingReference for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(siteDirectoryThingReference.Actor.HasValue) - { - writer.WriteStringValue(siteDirectoryThingReference.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteDirectoryThingReference.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteDirectoryThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteDirectoryThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteDirectoryThingReference.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteDirectoryThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("referencedRevisionNumber"u8); - writer.WriteNumberValue(siteDirectoryThingReference.ReferencedRevisionNumber); - writer.WritePropertyName("referencedThing"u8); - writer.WriteStringValue(siteDirectoryThingReference.ReferencedThing); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteDirectoryThingReference.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteDirectoryThingReference.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -203,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -211,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -229,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -247,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -265,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -283,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -301,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -319,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "referencedrevisionnumber": - if(!AllowedVersionsPerProperty["referencedRevisionNumber"].Contains(requestedVersion)) + var allowedVersionsForReferencedRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReferencedRevisionNumber.Contains(requestedVersion)) { return; } @@ -337,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "referencedthing": - if(!AllowedVersionsPerProperty["referencedThing"].Contains(requestedVersion)) + var allowedVersionsForReferencedThing = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForReferencedThing.Contains(requestedVersion)) { return; } @@ -355,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -373,7 +286,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -396,21 +315,144 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "referencedRevisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "referencedThing", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not SiteDirectoryThingReference siteDirectoryThingReference) + { + throw new ArgumentException("The thing shall be a SiteDirectoryThingReference", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SiteDirectoryThingReference since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectoryThingReference for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectoryThingReference.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteDirectoryThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectoryThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteDirectoryThingReference.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectoryThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("referencedRevisionNumber"u8); + writer.WriteNumberValue(siteDirectoryThingReference.ReferencedRevisionNumber); + writer.WritePropertyName("referencedThing"u8); + writer.WriteStringValue(siteDirectoryThingReference.ReferencedThing); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectoryThingReference.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectoryThingReference for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectoryThingReference.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteDirectoryThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectoryThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteDirectoryThingReference.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectoryThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("referencedRevisionNumber"u8); + writer.WriteNumberValue(siteDirectoryThingReference.ReferencedRevisionNumber); + writer.WritePropertyName("referencedThing"u8); + writer.WriteStringValue(siteDirectoryThingReference.ReferencedThing); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectoryThingReference.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteDirectoryThingReference.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SiteDirectoryThingReference for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(siteDirectoryThingReference.Actor.HasValue) + { + writer.WriteStringValue(siteDirectoryThingReference.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteDirectoryThingReference.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteDirectoryThingReference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteDirectoryThingReference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteDirectoryThingReference.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteDirectoryThingReference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("referencedRevisionNumber"u8); + writer.WriteNumberValue(siteDirectoryThingReference.ReferencedRevisionNumber); + writer.WritePropertyName("referencedThing"u8); + writer.WriteStringValue(siteDirectoryThingReference.ReferencedThing); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteDirectoryThingReference.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteDirectoryThingReference.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteLogEntrySerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteLogEntrySerializer.cs index 407871d7..89790245 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteLogEntrySerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteLogEntrySerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,371 +50,288 @@ namespace CDP4JsonSerializer public class SiteLogEntrySerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not SiteLogEntry siteLogEntry) - { - throw new ArgumentException("The thing shall be a SiteLogEntry", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of SiteLogEntry since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing SiteLogEntry for Version 1.0.0"); - writer.WriteStartArray("affectedDomainIid"u8); - - foreach(var affectedDomainIidItem in siteLogEntry.AffectedDomainIid) + case "actor": + var allowedVersionsForActor = new List { - writer.WriteStringValue(affectedDomainIidItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("affectedItemIid"u8); + "1.3.0", + }; - foreach(var affectedItemIidItem in siteLogEntry.AffectedItemIid) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(affectedItemIidItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("author"u8); - - if(siteLogEntry.Author.HasValue) + if(value != null) { - writer.WriteStringValue(siteLogEntry.Author.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("category"u8); + break; + case "affecteddomainiid": + var allowedVersionsForAffectedDomainIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in siteLogEntry.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAffectedDomainIid.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("affectedDomainIid"u8); + + if(value is IEnumerable objectListAffectedDomainIid) + { + foreach(var affectedDomainIidItem in objectListAffectedDomainIid) + { + writer.WriteStringValue((Guid)affectedDomainIidItem); + } + } - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteLogEntry.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(siteLogEntry.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteLogEntry.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(siteLogEntry.LanguageCode); - writer.WritePropertyName("level"u8); - writer.WriteStringValue(siteLogEntry.Level.ToString()); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteLogEntry.RevisionNumber); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing SiteLogEntry for Version 1.1.0"); - writer.WriteStartArray("affectedDomainIid"u8); + case "affecteditemiid": + var allowedVersionsForAffectedItemIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var affectedDomainIidItem in siteLogEntry.AffectedDomainIid) + if(!allowedVersionsForAffectedItemIid.Contains(requestedVersion)) { - writer.WriteStringValue(affectedDomainIidItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("affectedItemIid"u8); - foreach(var affectedItemIidItem in siteLogEntry.AffectedItemIid) + if(value is IEnumerable objectListAffectedItemIid) { - writer.WriteStringValue(affectedItemIidItem); + foreach(var affectedItemIidItem in objectListAffectedItemIid) + { + writer.WriteStringValue((Guid)affectedItemIidItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("author"u8); + writer.WriteEndArray(); + break; + case "author": + var allowedVersionsForAuthor = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(siteLogEntry.Author.HasValue) + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { - writer.WriteStringValue(siteLogEntry.Author.Value); + return; + } + + writer.WritePropertyName("author"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in siteLogEntry.Category.OrderBy(x => x, this.GuidComparer)) + break; + case "category": + var allowedVersionsForCategory = new List { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteLogEntry.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(siteLogEntry.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in siteLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("category"u8); - foreach(var excludedPersonItem in siteLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(excludedPersonItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteLogEntry.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(siteLogEntry.LanguageCode); - writer.WritePropertyName("level"u8); - writer.WriteStringValue(siteLogEntry.Level.ToString()); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteLogEntry.RevisionNumber); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SiteLogEntry for Version 1.2.0"); - writer.WriteStartArray("affectedDomainIid"u8); - - foreach(var affectedDomainIidItem in siteLogEntry.AffectedDomainIid) + case "classkind": + var allowedVersionsForClassKind = new List { - writer.WriteStringValue(affectedDomainIidItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("affectedItemIid"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var affectedItemIidItem in siteLogEntry.AffectedItemIid) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(affectedItemIidItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("author"u8); - - if(siteLogEntry.Author.HasValue) + if(value != null) { - writer.WriteStringValue(siteLogEntry.Author.Value); + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WriteStartArray("category"u8); + break; + case "content": + var allowedVersionsForContent = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in siteLogEntry.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForContent.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteLogEntry.ClassKind.ToString()); writer.WritePropertyName("content"u8); - writer.WriteStringValue(siteLogEntry.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteLogEntry.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(siteLogEntry.LanguageCode); - writer.WritePropertyName("level"u8); - writer.WriteStringValue(siteLogEntry.Level.ToString()); - writer.WriteStartArray("logEntryChangelogItem"u8); + break; + case "createdon": + var allowedVersionsForCreatedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var logEntryChangelogItemItem in siteLogEntry.LogEntryChangelogItem.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { - writer.WriteStringValue(logEntryChangelogItemItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("createdOn"u8); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteLogEntry.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteLogEntry.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SiteLogEntry for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(siteLogEntry.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(siteLogEntry.Actor.Value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { writer.WriteNullValue(); } - writer.WriteStartArray("affectedDomainIid"u8); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var affectedDomainIidItem in siteLogEntry.AffectedDomainIid) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(affectedDomainIidItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("affectedItemIid"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var affectedItemIidItem in siteLogEntry.AffectedItemIid) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(affectedItemIidItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("author"u8); - - if(siteLogEntry.Author.HasValue) - { - writer.WriteStringValue(siteLogEntry.Author.Value); - } - else + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List { - writer.WriteNullValue(); - } - - writer.WriteStartArray("category"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in siteLogEntry.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteLogEntry.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(siteLogEntry.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(siteLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in siteLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in siteLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteLogEntry.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(siteLogEntry.LanguageCode); - writer.WritePropertyName("level"u8); - writer.WriteStringValue(siteLogEntry.Level.ToString()); - writer.WriteStartArray("logEntryChangelogItem"u8); - - foreach(var logEntryChangelogItemItem in siteLogEntry.LogEntryChangelogItem.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(logEntryChangelogItemItem); - } - writer.WriteEndArray(); - - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteLogEntry.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteLogEntry.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("iid"u8); if(value != null) { @@ -427,53 +343,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "affecteddomainiid": - if(!AllowedVersionsPerProperty["affectedDomainIid"].Contains(requestedVersion)) + case "languagecode": + var allowedVersionsForLanguageCode = new List { - return; - } - - writer.WriteStartArray("affectedDomainIid"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAffectedDomainIid) + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { - foreach(var affectedDomainIidItem in objectListAffectedDomainIid) - { - writer.WriteStringValue((Guid)affectedDomainIidItem); - } + return; } + + writer.WritePropertyName("languageCode"u8); - writer.WriteEndArray(); - break; - case "affecteditemiid": - if(!AllowedVersionsPerProperty["affectedItemIid"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("affectedItemIid"u8); - - if(value is IEnumerable objectListAffectedItemIid) + else { - foreach(var affectedItemIidItem in objectListAffectedItemIid) - { - writer.WriteStringValue((Guid)affectedItemIidItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + case "level": + var allowedVersionsForLevel = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLevel.Contains(requestedVersion)) { return; } - writer.WritePropertyName("author"u8); + writer.WritePropertyName("level"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((LogLevelKind)value).ToString()); } else { @@ -481,35 +395,48 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "logentrychangelogitem": + var allowedVersionsForLogEntryChangelogItem = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLogEntryChangelogItem.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("logEntryChangelogItem"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListLogEntryChangelogItem) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var logEntryChangelogItemItem in objectListLogEntryChangelogItem.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(logEntryChangelogItemItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -517,17 +444,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("content"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteNumberValue((int)value); } else { @@ -535,17 +470,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("createdOn"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((string)value); } else { @@ -553,196 +494,335 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the SiteLogEntry"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not SiteLogEntry siteLogEntry) + { + throw new ArgumentException("The thing shall be a SiteLogEntry", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SiteLogEntry since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing SiteLogEntry for Version 1.0.0"); + writer.WriteStartArray("affectedDomainIid"u8); + + foreach(var affectedDomainIidItem in siteLogEntry.AffectedDomainIid) { - return; + writer.WriteStringValue(affectedDomainIidItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WriteStartArray("affectedItemIid"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var affectedItemIidItem in siteLogEntry.AffectedItemIid) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(affectedItemIidItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WritePropertyName("author"u8); + + if(siteLogEntry.Author.HasValue) { - return; + writer.WriteStringValue(siteLogEntry.Author.Value); + } + else + { + writer.WriteNullValue(); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var categoryItem in siteLogEntry.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteLogEntry.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(siteLogEntry.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteLogEntry.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(siteLogEntry.LanguageCode); + writer.WritePropertyName("level"u8); + writer.WriteStringValue(siteLogEntry.Level.ToString()); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteLogEntry.RevisionNumber); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing SiteLogEntry for Version 1.1.0"); + writer.WriteStartArray("affectedDomainIid"u8); + + foreach(var affectedDomainIidItem in siteLogEntry.AffectedDomainIid) { - return; + writer.WriteStringValue(affectedDomainIidItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("affectedItemIid"u8); + + foreach(var affectedItemIidItem in siteLogEntry.AffectedItemIid) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(affectedItemIidItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + + if(siteLogEntry.Author.HasValue) + { + writer.WriteStringValue(siteLogEntry.Author.Value); } else { writer.WriteNullValue(); } - break; - case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in siteLogEntry.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("languageCode"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteLogEntry.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(siteLogEntry.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteLogEntry.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(siteLogEntry.LanguageCode); + writer.WritePropertyName("level"u8); + writer.WriteStringValue(siteLogEntry.Level.ToString()); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteLogEntry.RevisionNumber); break; - case "level": - if(!AllowedVersionsPerProperty["level"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SiteLogEntry for Version 1.2.0"); + writer.WriteStartArray("affectedDomainIid"u8); + + foreach(var affectedDomainIidItem in siteLogEntry.AffectedDomainIid) { - return; + writer.WriteStringValue(affectedDomainIidItem); } - writer.WritePropertyName("level"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("affectedItemIid"u8); + + foreach(var affectedItemIidItem in siteLogEntry.AffectedItemIid) { - writer.WriteStringValue(((LogLevelKind)value).ToString()); + writer.WriteStringValue(affectedItemIidItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + + if(siteLogEntry.Author.HasValue) + { + writer.WriteStringValue(siteLogEntry.Author.Value); } else { writer.WriteNullValue(); } - break; - case "logentrychangelogitem": - if(!AllowedVersionsPerProperty["logEntryChangelogItem"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in siteLogEntry.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WriteStartArray("logEntryChangelogItem"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteLogEntry.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(siteLogEntry.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListLogEntryChangelogItem) + foreach(var excludedDomainItem in siteLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var logEntryChangelogItemItem in objectListLogEntryChangelogItem.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(logEntryChangelogItemItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteLogEntry.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(siteLogEntry.LanguageCode); + writer.WritePropertyName("level"u8); + writer.WriteStringValue(siteLogEntry.Level.ToString()); + writer.WriteStartArray("logEntryChangelogItem"u8); + + foreach(var logEntryChangelogItemItem in siteLogEntry.LogEntryChangelogItem.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(logEntryChangelogItemItem); + } + + writer.WriteEndArray(); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteStringValue(siteLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteLogEntry.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteLogEntry.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SiteLogEntry for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(siteLogEntry.Actor.HasValue) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(siteLogEntry.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteStartArray("affectedDomainIid"u8); + + foreach(var affectedDomainIidItem in siteLogEntry.AffectedDomainIid) { - return; + writer.WriteStringValue(affectedDomainIidItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("affectedItemIid"u8); + + foreach(var affectedItemIidItem in siteLogEntry.AffectedItemIid) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(affectedItemIidItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("author"u8); + + if(siteLogEntry.Author.HasValue) + { + writer.WriteStringValue(siteLogEntry.Author.Value); } else { writer.WriteNullValue(); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in siteLogEntry.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteLogEntry.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(siteLogEntry.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(siteLogEntry.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in siteLogEntry.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteLogEntry.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteLogEntry.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(siteLogEntry.LanguageCode); + writer.WritePropertyName("level"u8); + writer.WriteStringValue(siteLogEntry.Level.ToString()); + writer.WriteStartArray("logEntryChangelogItem"u8); + + foreach(var logEntryChangelogItemItem in siteLogEntry.LogEntryChangelogItem.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(logEntryChangelogItemItem); } + writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteLogEntry.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteLogEntry.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteLogEntry.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the SiteLogEntry"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "affectedDomainIid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "affectedItemIid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "author", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "level", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "logEntryChangelogItem", new []{ "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteReferenceDataLibrarySerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteReferenceDataLibrarySerializer.cs index d4efc972..138ecdcf 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SiteReferenceDataLibrarySerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SiteReferenceDataLibrarySerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,481 +50,822 @@ namespace CDP4JsonSerializer public class SiteReferenceDataLibrarySerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not SiteReferenceDataLibrary siteReferenceDataLibrary) - { - throw new ArgumentException("The thing shall be a SiteReferenceDataLibrary", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of SiteReferenceDataLibrary since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing SiteReferenceDataLibrary for Version 1.0.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in siteReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) + case "actor": + var allowedVersionsForActor = new List { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("baseQuantityKind"u8); + "1.3.0", + }; - foreach(var baseQuantityKindItem in siteReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteOrderedItem(baseQuantityKindItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("baseUnit"u8); - - foreach(var baseUnitItem in siteReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(baseUnitItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteReferenceDataLibrary.ClassKind.ToString()); - writer.WriteStartArray("constant"u8); - - foreach(var constantItem in siteReferenceDataLibrary.Constant.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(constantItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("definedCategory"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definedCategoryItem in siteReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definedCategoryItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("alias"u8); - foreach(var definitionItem in siteReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(definitionItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("fileType"u8); + writer.WriteEndArray(); + break; + case "basequantitykind": + var allowedVersionsForBaseQuantityKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var fileTypeItem in siteReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForBaseQuantityKind.Contains(requestedVersion)) { - writer.WriteStringValue(fileTypeItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("glossary"u8); + writer.WriteStartArray("baseQuantityKind"u8); - foreach(var glossaryItem in siteReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListBaseQuantityKind) { - writer.WriteStringValue(glossaryItem); + foreach(var baseQuantityKindItem in objectListBaseQuantityKind.OfType().OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(baseQuantityKindItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "baseunit": + var allowedVersionsForBaseUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in siteReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForBaseUnit.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteReferenceDataLibrary.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(siteReferenceDataLibrary.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(siteReferenceDataLibrary.Name); - writer.WriteStartArray("parameterType"u8); + writer.WriteStartArray("baseUnit"u8); - foreach(var parameterTypeItem in siteReferenceDataLibrary.ParameterType.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListBaseUnit) { - writer.WriteStringValue(parameterTypeItem); + foreach(var baseUnitItem in objectListBaseUnit.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(baseUnitItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("referenceSource"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var referenceSourceItem in siteReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(referenceSourceItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("requiredRdl"u8); - - if(siteReferenceDataLibrary.RequiredRdl.HasValue) + if(value != null) { - writer.WriteStringValue(siteReferenceDataLibrary.RequiredRdl.Value); + writer.WriteStringValue(((ClassKind)value).ToString()); } else { writer.WriteNullValue(); } - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteReferenceDataLibrary.RevisionNumber); - writer.WriteStartArray("rule"u8); - - foreach(var ruleItem in siteReferenceDataLibrary.Rule.OrderBy(x => x, this.GuidComparer)) + break; + case "constant": + var allowedVersionsForConstant = new List { - writer.WriteStringValue(ruleItem); - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WriteStartArray("scale"u8); - - foreach(var scaleItem in siteReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForConstant.Contains(requestedVersion)) { - writer.WriteStringValue(scaleItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(siteReferenceDataLibrary.ShortName); - writer.WriteStartArray("unit"u8); + writer.WriteStartArray("constant"u8); - foreach(var unitItem in siteReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListConstant) { - writer.WriteStringValue(unitItem); + foreach(var constantItem in objectListConstant.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(constantItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("unitPrefix"u8); - - foreach(var unitPrefixItem in siteReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(unitPrefixItem); - } - writer.WriteEndArray(); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing SiteReferenceDataLibrary for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "definedcategory": + var allowedVersionsForDefinedCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in siteReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinedCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("baseQuantityKind"u8); + writer.WriteStartArray("definedCategory"u8); - foreach(var baseQuantityKindItem in siteReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) + if(value is IEnumerable objectListDefinedCategory) { - writer.WriteOrderedItem(baseQuantityKindItem); + foreach(var definedCategoryItem in objectListDefinedCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definedCategoryItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("baseUnit"u8); + writer.WriteEndArray(); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var baseUnitItem in siteReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(baseUnitItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteReferenceDataLibrary.ClassKind.ToString()); - writer.WriteStartArray("constant"u8); + writer.WriteStartArray("definition"u8); - foreach(var constantItem in siteReferenceDataLibrary.Constant.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(constantItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("definedCategory"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definedCategoryItem in siteReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(definedCategoryItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var definitionItem in siteReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(definitionItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in siteReferenceDataLibrary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedPersonItem in siteReferenceDataLibrary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedPersonItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("fileType"u8); + writer.WriteEndArray(); + break; + case "filetype": + var allowedVersionsForFileType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var fileTypeItem in siteReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForFileType.Contains(requestedVersion)) { - writer.WriteStringValue(fileTypeItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("glossary"u8); + writer.WriteStartArray("fileType"u8); - foreach(var glossaryItem in siteReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListFileType) { - writer.WriteStringValue(glossaryItem); + foreach(var fileTypeItem in objectListFileType.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileTypeItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "glossary": + var allowedVersionsForGlossary = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in siteReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForGlossary.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("glossary"u8); + + if(value is IEnumerable objectListGlossary) + { + foreach(var glossaryItem in objectListGlossary.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(glossaryItem); + } + } - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteReferenceDataLibrary.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(siteReferenceDataLibrary.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteReferenceDataLibrary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(siteReferenceDataLibrary.Name); - writer.WriteStartArray("parameterType"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var parameterTypeItem in siteReferenceDataLibrary.ParameterType.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(parameterTypeItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } - writer.WriteStartArray("referenceSource"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var referenceSourceItem in siteReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(referenceSourceItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("requiredRdl"u8); - - if(siteReferenceDataLibrary.RequiredRdl.HasValue) + if(value != null) { - writer.WriteStringValue(siteReferenceDataLibrary.RequiredRdl.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(siteReferenceDataLibrary.RevisionNumber); - writer.WriteStartArray("rule"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var ruleItem in siteReferenceDataLibrary.Rule.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(ruleItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("scale"u8); - - foreach(var scaleItem in siteReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(scaleItem); + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(siteReferenceDataLibrary.ShortName); - writer.WriteStartArray("unit"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var unitItem in siteReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(unitItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("unitPrefix"u8); - - foreach(var unitPrefixItem in siteReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(unitPrefixItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SiteReferenceDataLibrary for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in siteReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WriteStartArray("baseQuantityKind"u8); - - foreach(var baseQuantityKindItem in siteReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) + if(value != null) { - writer.WriteOrderedItem(baseQuantityKindItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("baseUnit"u8); + break; + case "parametertype": + var allowedVersionsForParameterType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var baseUnitItem in siteReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForParameterType.Contains(requestedVersion)) { - writer.WriteStringValue(baseUnitItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(siteReferenceDataLibrary.ClassKind.ToString()); - writer.WriteStartArray("constant"u8); + writer.WriteStartArray("parameterType"u8); - foreach(var constantItem in siteReferenceDataLibrary.Constant.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListParameterType) { - writer.WriteStringValue(constantItem); + foreach(var parameterTypeItem in objectListParameterType.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(parameterTypeItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("definedCategory"u8); + writer.WriteEndArray(); + break; + case "referencesource": + var allowedVersionsForReferenceSource = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definedCategoryItem in siteReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForReferenceSource.Contains(requestedVersion)) { - writer.WriteStringValue(definedCategoryItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("referenceSource"u8); - foreach(var definitionItem in siteReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListReferenceSource) { - writer.WriteStringValue(definitionItem); + foreach(var referenceSourceItem in objectListReferenceSource.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referenceSourceItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "requiredrdl": + var allowedVersionsForRequiredRdl = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in siteReferenceDataLibrary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRequiredRdl.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("requiredRdl"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in siteReferenceDataLibrary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("fileType"u8); + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var fileTypeItem in siteReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - writer.WriteStringValue(fileTypeItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); - writer.WriteStartArray("glossary"u8); - - foreach(var glossaryItem in siteReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(glossaryItem); + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "rule": + var allowedVersionsForRule = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in siteReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRule.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(siteReferenceDataLibrary.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(siteReferenceDataLibrary.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(siteReferenceDataLibrary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("rule"u8); + + if(value is IEnumerable objectListRule) + { + foreach(var ruleItem in objectListRule.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(ruleItem); + } + } + + writer.WriteEndArray(); + break; + case "scale": + var allowedVersionsForScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForScale.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("scale"u8); + + if(value is IEnumerable objectListScale) + { + foreach(var scaleItem in objectListScale.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(scaleItem); + } + } + + writer.WriteEndArray(); + break; + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("shortName"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "unit": + var allowedVersionsForUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUnit.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("unit"u8); + + if(value is IEnumerable objectListUnit) + { + foreach(var unitItem in objectListUnit.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(unitItem); + } + } + + writer.WriteEndArray(); + break; + case "unitprefix": + var allowedVersionsForUnitPrefix = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUnitPrefix.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("unitPrefix"u8); + + if(value is IEnumerable objectListUnitPrefix) + { + foreach(var unitPrefixItem in objectListUnitPrefix.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(unitPrefixItem); + } + } + + writer.WriteEndArray(); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the SiteReferenceDataLibrary"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not SiteReferenceDataLibrary siteReferenceDataLibrary) + { + throw new ArgumentException("The thing shall be a SiteReferenceDataLibrary", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SiteReferenceDataLibrary since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing SiteReferenceDataLibrary for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in siteReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("baseQuantityKind"u8); + + foreach(var baseQuantityKindItem in siteReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) + { + writer.WriteOrderedItem(baseQuantityKindItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("baseUnit"u8); + + foreach(var baseUnitItem in siteReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(baseUnitItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteReferenceDataLibrary.ClassKind.ToString()); + writer.WriteStartArray("constant"u8); + + foreach(var constantItem in siteReferenceDataLibrary.Constant.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(constantItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("definedCategory"u8); + + foreach(var definedCategoryItem in siteReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definedCategoryItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in siteReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("fileType"u8); + + foreach(var fileTypeItem in siteReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(fileTypeItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("glossary"u8); + + foreach(var glossaryItem in siteReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(glossaryItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in siteReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteReferenceDataLibrary.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(siteReferenceDataLibrary.IsDeprecated); writer.WritePropertyName("name"u8); writer.WriteStringValue(siteReferenceDataLibrary.Name); writer.WriteStartArray("parameterType"u8); @@ -536,7 +876,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("referenceSource"u8); foreach(var referenceSourceItem in siteReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) @@ -545,7 +884,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("requiredRdl"u8); if(siteReferenceDataLibrary.RequiredRdl.HasValue) @@ -567,7 +905,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("scale"u8); foreach(var scaleItem in siteReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) @@ -576,11 +913,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("shortName"u8); writer.WriteStringValue(siteReferenceDataLibrary.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteReferenceDataLibrary.ThingPreference); writer.WriteStartArray("unit"u8); foreach(var unitItem in siteReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) @@ -589,7 +923,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("unitPrefix"u8); foreach(var unitPrefixItem in siteReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) @@ -598,21 +931,9 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SiteReferenceDataLibrary for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(siteReferenceDataLibrary.Actor.HasValue) - { - writer.WriteStringValue(siteReferenceDataLibrary.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing SiteReferenceDataLibrary for Version 1.1.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in siteReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) @@ -621,7 +942,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("baseQuantityKind"u8); foreach(var baseQuantityKindItem in siteReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) @@ -630,7 +950,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("baseUnit"u8); foreach(var baseUnitItem in siteReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) @@ -639,7 +958,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(siteReferenceDataLibrary.ClassKind.ToString()); writer.WriteStartArray("constant"u8); @@ -650,7 +968,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("definedCategory"u8); foreach(var definedCategoryItem in siteReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) @@ -659,7 +976,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("definition"u8); foreach(var definitionItem in siteReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) @@ -668,7 +984,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in siteReferenceDataLibrary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -677,7 +992,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in siteReferenceDataLibrary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -686,7 +1000,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("fileType"u8); foreach(var fileTypeItem in siteReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) @@ -695,7 +1008,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("glossary"u8); foreach(var glossaryItem in siteReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) @@ -704,7 +1016,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in siteReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -713,7 +1024,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(siteReferenceDataLibrary.Iid); writer.WritePropertyName("isDeprecated"u8); @@ -730,7 +1040,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("referenceSource"u8); foreach(var referenceSourceItem in siteReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) @@ -739,7 +1048,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("requiredRdl"u8); if(siteReferenceDataLibrary.RequiredRdl.HasValue) @@ -761,7 +1069,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("scale"u8); foreach(var scaleItem in siteReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) @@ -770,11 +1077,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("shortName"u8); writer.WriteStringValue(siteReferenceDataLibrary.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(siteReferenceDataLibrary.ThingPreference); writer.WriteStartArray("unit"u8); foreach(var unitItem in siteReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) @@ -783,7 +1087,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("unitPrefix"u8); foreach(var unitPrefixItem in siteReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) @@ -792,553 +1095,356 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SiteReferenceDataLibrary for Version 1.2.0"); writer.WriteStartArray("alias"u8); - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "basequantitykind": - if(!AllowedVersionsPerProperty["baseQuantityKind"].Contains(requestedVersion)) + foreach(var aliasItem in siteReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } + writer.WriteEndArray(); writer.WriteStartArray("baseQuantityKind"u8); - if(value is IEnumerable objectListBaseQuantityKind) - { - foreach(var baseQuantityKindItem in objectListBaseQuantityKind.OfType().OrderBy(x => x, this.OrderedItemComparer)) - { - writer.WriteOrderedItem(baseQuantityKindItem); - } - } - - writer.WriteEndArray(); - break; - case "baseunit": - if(!AllowedVersionsPerProperty["baseUnit"].Contains(requestedVersion)) + foreach(var baseQuantityKindItem in siteReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) { - return; + writer.WriteOrderedItem(baseQuantityKindItem); } + writer.WriteEndArray(); writer.WriteStartArray("baseUnit"u8); - if(value is IEnumerable objectListBaseUnit) - { - foreach(var baseUnitItem in objectListBaseUnit.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(baseUnitItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + foreach(var baseUnitItem in siteReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(baseUnitItem); } + writer.WriteEndArray(); writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "constant": - if(!AllowedVersionsPerProperty["constant"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(siteReferenceDataLibrary.ClassKind.ToString()); writer.WriteStartArray("constant"u8); - if(value is IEnumerable objectListConstant) - { - foreach(var constantItem in objectListConstant.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(constantItem); - } - } - - writer.WriteEndArray(); - break; - case "definedcategory": - if(!AllowedVersionsPerProperty["definedCategory"].Contains(requestedVersion)) + foreach(var constantItem in siteReferenceDataLibrary.Constant.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(constantItem); } + writer.WriteEndArray(); writer.WriteStartArray("definedCategory"u8); - if(value is IEnumerable objectListDefinedCategory) - { - foreach(var definedCategoryItem in objectListDefinedCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definedCategoryItem); - } - } - - writer.WriteEndArray(); - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + foreach(var definedCategoryItem in siteReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definedCategoryItem); } + writer.WriteEndArray(); writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + foreach(var definitionItem in siteReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + foreach(var excludedDomainItem in siteReferenceDataLibrary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "filetype": - if(!AllowedVersionsPerProperty["fileType"].Contains(requestedVersion)) + foreach(var excludedPersonItem in siteReferenceDataLibrary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WriteStartArray("fileType"u8); - if(value is IEnumerable objectListFileType) - { - foreach(var fileTypeItem in objectListFileType.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(fileTypeItem); - } - } - - writer.WriteEndArray(); - break; - case "glossary": - if(!AllowedVersionsPerProperty["glossary"].Contains(requestedVersion)) + foreach(var fileTypeItem in siteReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(fileTypeItem); } + writer.WriteEndArray(); writer.WriteStartArray("glossary"u8); - if(value is IEnumerable objectListGlossary) - { - foreach(var glossaryItem in objectListGlossary.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(glossaryItem); - } - } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + foreach(var glossaryItem in siteReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(glossaryItem); } + writer.WriteEndArray(); writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + foreach(var hyperLinkItem in siteReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(siteReferenceDataLibrary.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - + writer.WriteBooleanValue(siteReferenceDataLibrary.IsDeprecated); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else + writer.WriteStringValue(siteReferenceDataLibrary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(siteReferenceDataLibrary.Name); + writer.WriteStartArray("parameterType"u8); + + foreach(var parameterTypeItem in siteReferenceDataLibrary.ParameterType.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(parameterTypeItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("referenceSource"u8); + + foreach(var referenceSourceItem in siteReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(referenceSourceItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("requiredRdl"u8); + + if(siteReferenceDataLibrary.RequiredRdl.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(siteReferenceDataLibrary.RequiredRdl.Value); } else { writer.WriteNullValue(); } - break; - case "parametertype": - if(!AllowedVersionsPerProperty["parameterType"].Contains(requestedVersion)) + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteReferenceDataLibrary.RevisionNumber); + writer.WriteStartArray("rule"u8); + + foreach(var ruleItem in siteReferenceDataLibrary.Rule.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(ruleItem); } - writer.WriteStartArray("parameterType"u8); + writer.WriteEndArray(); + writer.WriteStartArray("scale"u8); - if(value is IEnumerable objectListParameterType) + foreach(var scaleItem in siteReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) { - foreach(var parameterTypeItem in objectListParameterType.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(parameterTypeItem); - } + writer.WriteStringValue(scaleItem); } - + writer.WriteEndArray(); - break; - case "referencesource": - if(!AllowedVersionsPerProperty["referenceSource"].Contains(requestedVersion)) + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(siteReferenceDataLibrary.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteReferenceDataLibrary.ThingPreference); + writer.WriteStartArray("unit"u8); + + foreach(var unitItem in siteReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(unitItem); } - writer.WriteStartArray("referenceSource"u8); + writer.WriteEndArray(); + writer.WriteStartArray("unitPrefix"u8); - if(value is IEnumerable objectListReferenceSource) + foreach(var unitPrefixItem in siteReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) { - foreach(var referenceSourceItem in objectListReferenceSource.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(referenceSourceItem); - } + writer.WriteStringValue(unitPrefixItem); } - + writer.WriteEndArray(); break; - case "requiredrdl": - if(!AllowedVersionsPerProperty["requiredRdl"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SiteReferenceDataLibrary for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("requiredRdl"u8); - - if(value != null) + if(siteReferenceDataLibrary.Actor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(siteReferenceDataLibrary.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in siteReferenceDataLibrary.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("baseQuantityKind"u8); + + foreach(var baseQuantityKindItem in siteReferenceDataLibrary.BaseQuantityKind.OrderBy(x => x, this.OrderedItemComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteOrderedItem(baseQuantityKindItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("baseUnit"u8); + + foreach(var baseUnitItem in siteReferenceDataLibrary.BaseUnit.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(baseUnitItem); } - break; - case "rule": - if(!AllowedVersionsPerProperty["rule"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(siteReferenceDataLibrary.ClassKind.ToString()); + writer.WriteStartArray("constant"u8); + + foreach(var constantItem in siteReferenceDataLibrary.Constant.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(constantItem); } - writer.WriteStartArray("rule"u8); + writer.WriteEndArray(); + writer.WriteStartArray("definedCategory"u8); - if(value is IEnumerable objectListRule) + foreach(var definedCategoryItem in siteReferenceDataLibrary.DefinedCategory.OrderBy(x => x, this.GuidComparer)) { - foreach(var ruleItem in objectListRule.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(ruleItem); - } + writer.WriteStringValue(definedCategoryItem); } - + writer.WriteEndArray(); - break; - case "scale": - if(!AllowedVersionsPerProperty["scale"].Contains(requestedVersion)) + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in siteReferenceDataLibrary.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WriteStartArray("scale"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListScale) + foreach(var excludedDomainItem in siteReferenceDataLibrary.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var scaleItem in objectListScale.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(scaleItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in siteReferenceDataLibrary.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("fileType"u8); + + foreach(var fileTypeItem in siteReferenceDataLibrary.FileType.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(fileTypeItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("glossary"u8); + + foreach(var glossaryItem in siteReferenceDataLibrary.Glossary.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(glossaryItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in siteReferenceDataLibrary.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(siteReferenceDataLibrary.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(siteReferenceDataLibrary.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(siteReferenceDataLibrary.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(siteReferenceDataLibrary.Name); + writer.WriteStartArray("parameterType"u8); + + foreach(var parameterTypeItem in siteReferenceDataLibrary.ParameterType.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(parameterTypeItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("referenceSource"u8); + + foreach(var referenceSourceItem in siteReferenceDataLibrary.ReferenceSource.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(referenceSourceItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("requiredRdl"u8); + + if(siteReferenceDataLibrary.RequiredRdl.HasValue) + { + writer.WriteStringValue(siteReferenceDataLibrary.RequiredRdl.Value); } else { writer.WriteNullValue(); } - break; - case "unit": - if(!AllowedVersionsPerProperty["unit"].Contains(requestedVersion)) + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(siteReferenceDataLibrary.RevisionNumber); + writer.WriteStartArray("rule"u8); + + foreach(var ruleItem in siteReferenceDataLibrary.Rule.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(ruleItem); } - writer.WriteStartArray("unit"u8); + writer.WriteEndArray(); + writer.WriteStartArray("scale"u8); - if(value is IEnumerable objectListUnit) + foreach(var scaleItem in siteReferenceDataLibrary.Scale.OrderBy(x => x, this.GuidComparer)) { - foreach(var unitItem in objectListUnit.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(unitItem); - } + writer.WriteStringValue(scaleItem); } - + writer.WriteEndArray(); - break; - case "unitprefix": - if(!AllowedVersionsPerProperty["unitPrefix"].Contains(requestedVersion)) + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(siteReferenceDataLibrary.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(siteReferenceDataLibrary.ThingPreference); + writer.WriteStartArray("unit"u8); + + foreach(var unitItem in siteReferenceDataLibrary.Unit.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(unitItem); } + writer.WriteEndArray(); writer.WriteStartArray("unitPrefix"u8); - if(value is IEnumerable objectListUnitPrefix) + foreach(var unitPrefixItem in siteReferenceDataLibrary.UnitPrefix.OrderBy(x => x, this.GuidComparer)) { - foreach(var unitPrefixItem in objectListUnitPrefix.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(unitPrefixItem); - } + writer.WriteStringValue(unitPrefixItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the SiteReferenceDataLibrary"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "baseQuantityKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "baseUnit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "constant", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definedCategory", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "fileType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "glossary", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "parameterType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "referenceSource", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "requiredRdl", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "rule", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "scale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "unit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "unitPrefix", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SolutionSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SolutionSerializer.cs index 4bfe39b1..96fb334f 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SolutionSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SolutionSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,170 +49,6 @@ namespace CDP4JsonSerializer /// public class SolutionSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not Solution solution) - { - throw new ArgumentException("The thing shall be a Solution", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Solution since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Solution for Version 1.1.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(solution.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(solution.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(solution.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(solution.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in solution.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in solution.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(solution.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(solution.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(solution.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(solution.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(solution.RevisionNumber); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Solution for Version 1.2.0"); - writer.WritePropertyName("author"u8); - writer.WriteStringValue(solution.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(solution.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(solution.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(solution.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in solution.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in solution.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(solution.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(solution.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(solution.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(solution.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(solution.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(solution.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Solution for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(solution.Actor.HasValue) - { - writer.WriteStringValue(solution.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("author"u8); - writer.WriteStringValue(solution.Author); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(solution.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(solution.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(solution.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in solution.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in solution.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(solution.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(solution.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(solution.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(solution.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(solution.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(solution.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -221,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -229,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -247,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "author": - if(!AllowedVersionsPerProperty["author"].Contains(requestedVersion)) + var allowedVersionsForAuthor = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAuthor.Contains(requestedVersion)) { return; } @@ -265,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -283,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContent.Contains(requestedVersion)) { return; } @@ -301,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -319,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -337,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -355,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -373,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + var allowedVersionsForLanguageCode = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } @@ -391,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -409,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -427,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -445,7 +361,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -468,24 +390,162 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "author", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not Solution solution) + { + throw new ArgumentException("The thing shall be a Solution", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Solution since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Solution for Version 1.1.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(solution.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(solution.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(solution.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(solution.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in solution.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in solution.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(solution.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(solution.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(solution.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(solution.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(solution.RevisionNumber); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Solution for Version 1.2.0"); + writer.WritePropertyName("author"u8); + writer.WriteStringValue(solution.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(solution.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(solution.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(solution.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in solution.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in solution.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(solution.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(solution.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(solution.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(solution.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(solution.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(solution.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Solution for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(solution.Actor.HasValue) + { + writer.WriteStringValue(solution.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("author"u8); + writer.WriteStringValue(solution.Author); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(solution.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(solution.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(solution.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in solution.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in solution.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(solution.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(solution.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(solution.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(solution.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(solution.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(solution.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/SpecializedQuantityKindSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/SpecializedQuantityKindSerializer.cs index eac93765..411b0211 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/SpecializedQuantityKindSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/SpecializedQuantityKindSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,409 +50,343 @@ namespace CDP4JsonSerializer public class SpecializedQuantityKindSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not SpecializedQuantityKind specializedQuantityKind) - { - throw new ArgumentException("The thing shall be a SpecializedQuantityKind", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of SpecializedQuantityKind since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing SpecializedQuantityKind for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in specializedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in specializedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(specializedQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(specializedQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in specializedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("general"u8); - writer.WriteStringValue(specializedQuantityKind.General); - writer.WriteStartArray("hyperLink"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in specializedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(specializedQuantityKind.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(specializedQuantityKind.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(specializedQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); + writer.WriteStartArray("alias"u8); - foreach(var possibleScaleItem in specializedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(possibleScaleItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(specializedQuantityKind.QuantityDimensionSymbol); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(specializedQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(specializedQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(specializedQuantityKind.Symbol); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing SpecializedQuantityKind for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in specializedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in specializedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(specializedQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(specializedQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in specializedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in specializedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in specializedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("general"u8); - writer.WriteStringValue(specializedQuantityKind.General); - writer.WriteStartArray("hyperLink"u8); + break; + case "defaultscale": + var allowedVersionsForDefaultScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in specializedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefaultScale.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("defaultScale"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(specializedQuantityKind.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(specializedQuantityKind.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(specializedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(specializedQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); - - foreach(var possibleScaleItem in specializedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(possibleScaleItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(specializedQuantityKind.QuantityDimensionSymbol); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(specializedQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(specializedQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(specializedQuantityKind.Symbol); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing SpecializedQuantityKind for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in specializedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("definition"u8); - foreach(var categoryItem in specializedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(categoryItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(specializedQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(specializedQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in specializedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); - foreach(var excludedDomainItem in specializedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in specializedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } - writer.WritePropertyName("general"u8); - writer.WriteStringValue(specializedQuantityKind.General); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "general": + var allowedVersionsForGeneral = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in specializedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForGeneral.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("general"u8); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(specializedQuantityKind.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(specializedQuantityKind.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(specializedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(specializedQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); - - foreach(var possibleScaleItem in specializedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(possibleScaleItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(specializedQuantityKind.QuantityDimensionSymbol); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(specializedQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(specializedQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(specializedQuantityKind.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(specializedQuantityKind.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing SpecializedQuantityKind for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(specializedQuantityKind.Actor.HasValue) + if(value != null) { - writer.WriteStringValue(specializedQuantityKind.Actor.Value); + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in specializedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var categoryItem in specializedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(categoryItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(specializedQuantityKind.ClassKind.ToString()); - writer.WritePropertyName("defaultScale"u8); - writer.WriteStringValue(specializedQuantityKind.DefaultScale); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in specializedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in specializedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in specializedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("general"u8); - writer.WriteStringValue(specializedQuantityKind.General); - writer.WriteStartArray("hyperLink"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in specializedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(specializedQuantityKind.Iid); writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(specializedQuantityKind.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(specializedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(specializedQuantityKind.Name); - writer.WriteStartArray("possibleScale"u8); - - foreach(var possibleScaleItem in specializedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(possibleScaleItem); + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("quantityDimensionSymbol"u8); - writer.WriteStringValue(specializedQuantityKind.QuantityDimensionSymbol); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(specializedQuantityKind.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(specializedQuantityKind.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(specializedQuantityKind.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(specializedQuantityKind.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -461,53 +394,77 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) + writer.WritePropertyName("name"u8); + + if(value != null) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); + else + { + writer.WriteNullValue(); + } + break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "possiblescale": + var allowedVersionsForPossibleScale = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForPossibleScale.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("possibleScale"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListPossibleScale) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var possibleScaleItem in objectListPossibleScale.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(possibleScaleItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "quantitydimensionsymbol": + var allowedVersionsForQuantityDimensionSymbol = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForQuantityDimensionSymbol.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("quantityDimensionSymbol"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -515,17 +472,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "defaultscale": - if(!AllowedVersionsPerProperty["defaultScale"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("defaultScale"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -533,71 +498,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List { - return; - } - - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } + writer.WritePropertyName("shortName"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "general": - if(!AllowedVersionsPerProperty["general"].Contains(requestedVersion)) + case "symbol": + var allowedVersionsForSymbol = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { return; } - writer.WritePropertyName("general"u8); + writer.WritePropertyName("symbol"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -605,35 +550,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List { - return; - } - - writer.WriteStartArray("hyperLink"u8); + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -641,199 +574,363 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the SpecializedQuantityKind"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not SpecializedQuantityKind specializedQuantityKind) + { + throw new ArgumentException("The thing shall be a SpecializedQuantityKind", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of SpecializedQuantityKind since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing SpecializedQuantityKind for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in specializedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in specializedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(specializedQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(specializedQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in specializedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("general"u8); + writer.WriteStringValue(specializedQuantityKind.General); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in specializedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(specializedQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(specializedQuantityKind.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(specializedQuantityKind.Name); + writer.WriteStartArray("possibleScale"u8); + + foreach(var possibleScaleItem in specializedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(possibleScaleItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(specializedQuantityKind.QuantityDimensionSymbol); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(specializedQuantityKind.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(specializedQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(specializedQuantityKind.Symbol); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing SpecializedQuantityKind for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in specializedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(aliasItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in specializedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(specializedQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(specializedQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in specializedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in specializedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "possiblescale": - if(!AllowedVersionsPerProperty["possibleScale"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in specializedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("general"u8); + writer.WriteStringValue(specializedQuantityKind.General); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in specializedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(specializedQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(specializedQuantityKind.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(specializedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(specializedQuantityKind.Name); writer.WriteStartArray("possibleScale"u8); - if(value is IEnumerable objectListPossibleScale) + foreach(var possibleScaleItem in specializedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) { - foreach(var possibleScaleItem in objectListPossibleScale.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(possibleScaleItem); - } + writer.WriteStringValue(possibleScaleItem); } - + writer.WriteEndArray(); + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(specializedQuantityKind.QuantityDimensionSymbol); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(specializedQuantityKind.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(specializedQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(specializedQuantityKind.Symbol); break; - case "quantitydimensionsymbol": - if(!AllowedVersionsPerProperty["quantityDimensionSymbol"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing SpecializedQuantityKind for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in specializedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("quantityDimensionSymbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in specializedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(specializedQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(specializedQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in specializedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in specializedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in specializedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("general"u8); + writer.WriteStringValue(specializedQuantityKind.General); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in specializedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(specializedQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(specializedQuantityKind.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(specializedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(specializedQuantityKind.Name); + writer.WriteStartArray("possibleScale"u8); + + foreach(var possibleScaleItem in specializedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(possibleScaleItem); } + writer.WriteEndArray(); + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(specializedQuantityKind.QuantityDimensionSymbol); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(specializedQuantityKind.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(specializedQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(specializedQuantityKind.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(specializedQuantityKind.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing SpecializedQuantityKind for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(specializedQuantityKind.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(specializedQuantityKind.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in specializedQuantityKind.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("symbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in specializedQuantityKind.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(specializedQuantityKind.ClassKind.ToString()); + writer.WritePropertyName("defaultScale"u8); + writer.WriteStringValue(specializedQuantityKind.DefaultScale); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in specializedQuantityKind.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in specializedQuantityKind.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in specializedQuantityKind.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("general"u8); + writer.WriteStringValue(specializedQuantityKind.General); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in specializedQuantityKind.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(specializedQuantityKind.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(specializedQuantityKind.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(specializedQuantityKind.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(specializedQuantityKind.Name); + writer.WriteStartArray("possibleScale"u8); + + foreach(var possibleScaleItem in specializedQuantityKind.PossibleScale.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(possibleScaleItem); } + writer.WriteEndArray(); + writer.WritePropertyName("quantityDimensionSymbol"u8); + writer.WriteStringValue(specializedQuantityKind.QuantityDimensionSymbol); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(specializedQuantityKind.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(specializedQuantityKind.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(specializedQuantityKind.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(specializedQuantityKind.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the SpecializedQuantityKind"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "defaultScale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "general", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "possibleScale", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "quantityDimensionSymbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/StakeHolderValueMapSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/StakeHolderValueMapSerializer.cs index 140d5294..336a6204 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/StakeHolderValueMapSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/StakeHolderValueMapSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,419 +50,359 @@ namespace CDP4JsonSerializer public class StakeHolderValueMapSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not StakeHolderValueMap stakeHolderValueMap) - { - throw new ArgumentException("The thing shall be a StakeHolderValueMap", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of StakeHolderValueMap since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing StakeHolderValueMap for Version 1.1.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in stakeHolderValueMap.Alias.OrderBy(x => x, this.GuidComparer)) + case "actor": + var allowedVersionsForActor = new List { - writer.WriteStringValue(aliasItem); - } + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in stakeHolderValueMap.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(stakeHolderValueMap.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in stakeHolderValueMap.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in stakeHolderValueMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in stakeHolderValueMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("goal"u8); + writer.WriteStartArray("alias"u8); - foreach(var goalItem in stakeHolderValueMap.Goal.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(goalItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in stakeHolderValueMap.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(stakeHolderValueMap.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(stakeHolderValueMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(stakeHolderValueMap.Name); - writer.WriteStartArray("requirement"u8); + writer.WriteStartArray("category"u8); - foreach(var requirementItem in stakeHolderValueMap.Requirement.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(requirementItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(stakeHolderValueMap.RevisionNumber); - writer.WriteStartArray("settings"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var settingsItem in stakeHolderValueMap.Settings.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(settingsItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(stakeHolderValueMap.ShortName); - writer.WriteStartArray("stakeholderValue"u8); - - foreach(var stakeholderValueItem in stakeHolderValueMap.StakeholderValue.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(stakeholderValueItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("valueGroup"u8); - - foreach(var valueGroupItem in stakeHolderValueMap.ValueGroup.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(valueGroupItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing StakeHolderValueMap for Version 1.2.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in stakeHolderValueMap.Alias.OrderBy(x => x, this.GuidComparer)) + case "definition": + var allowedVersionsForDefinition = new List { - writer.WriteStringValue(aliasItem); - } + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in stakeHolderValueMap.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(stakeHolderValueMap.ClassKind.ToString()); writer.WriteStartArray("definition"u8); - foreach(var definitionItem in stakeHolderValueMap.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(definitionItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in stakeHolderValueMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in stakeHolderValueMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("goal"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var goalItem in stakeHolderValueMap.Goal.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(goalItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var hyperLinkItem in stakeHolderValueMap.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(hyperLinkItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(stakeHolderValueMap.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(stakeHolderValueMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(stakeHolderValueMap.Name); - writer.WriteStartArray("requirement"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var requirementItem in stakeHolderValueMap.Requirement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(requirementItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(stakeHolderValueMap.RevisionNumber); - writer.WriteStartArray("settings"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var settingsItem in stakeHolderValueMap.Settings.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(settingsItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(stakeHolderValueMap.ShortName); - writer.WriteStartArray("stakeholderValue"u8); + writer.WriteEndArray(); + break; + case "goal": + var allowedVersionsForGoal = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var stakeholderValueItem in stakeHolderValueMap.StakeholderValue.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForGoal.Contains(requestedVersion)) { - writer.WriteStringValue(stakeholderValueItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(stakeHolderValueMap.ThingPreference); - writer.WriteStartArray("valueGroup"u8); + writer.WriteStartArray("goal"u8); - foreach(var valueGroupItem in stakeHolderValueMap.ValueGroup.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListGoal) { - writer.WriteStringValue(valueGroupItem); + foreach(var goalItem in objectListGoal.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(goalItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing StakeHolderValueMap for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(stakeHolderValueMap.Actor.HasValue) + case "hyperlink": + var allowedVersionsForHyperLink = new List { - writer.WriteStringValue(stakeHolderValueMap.Actor.Value); - } - else + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteNullValue(); + return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("hyperLink"u8); - foreach(var aliasItem in stakeHolderValueMap.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(aliasItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var categoryItem in stakeHolderValueMap.Category.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(categoryItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(stakeHolderValueMap.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in stakeHolderValueMap.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in stakeHolderValueMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in stakeHolderValueMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("goal"u8); - - foreach(var goalItem in stakeHolderValueMap.Goal.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(goalItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in stakeHolderValueMap.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(stakeHolderValueMap.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(stakeHolderValueMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(stakeHolderValueMap.Name); - writer.WriteStartArray("requirement"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var requirementItem in stakeHolderValueMap.Requirement.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(requirementItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(stakeHolderValueMap.RevisionNumber); - writer.WriteStartArray("settings"u8); - - foreach(var settingsItem in stakeHolderValueMap.Settings.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(settingsItem); + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(stakeHolderValueMap.ShortName); - writer.WriteStartArray("stakeholderValue"u8); + break; + case "requirement": + var allowedVersionsForRequirement = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var stakeholderValueItem in stakeHolderValueMap.StakeholderValue.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRequirement.Contains(requestedVersion)) { - writer.WriteStringValue(stakeholderValueItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(stakeHolderValueMap.ThingPreference); - writer.WriteStartArray("valueGroup"u8); + writer.WriteStartArray("requirement"u8); - foreach(var valueGroupItem in stakeHolderValueMap.ValueGroup.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListRequirement) { - writer.WriteStringValue(valueGroupItem); + foreach(var requirementItem in objectListRequirement.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(requirementItem); + } } - - writer.WriteEndArray(); + writer.WriteEndArray(); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -471,53 +410,98 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "settings": + var allowedVersionsForSettings = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForSettings.Contains(requestedVersion)) { return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("settings"u8); - if(value is IEnumerable objectListAlias) + if(value is IEnumerable objectListSettings) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var settingsItem in objectListSettings.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(aliasItem); + writer.WriteStringValue(settingsItem); } } writer.WriteEndArray(); break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WritePropertyName("shortName"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - if(value is IEnumerable objectListCategory) + break; + case "stakeholdervalue": + var allowedVersionsForStakeholderValue = new List { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStakeholderValue.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("stakeholderValue"u8); + + if(value is IEnumerable objectListStakeholderValue) + { + foreach(var stakeholderValueItem in objectListStakeholderValue.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(stakeholderValueItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -525,306 +509,391 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "valuegroup": + var allowedVersionsForValueGroup = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueGroup.Contains(requestedVersion)) { return; } - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("valueGroup"u8); - if(value is IEnumerable objectListDefinition) + if(value is IEnumerable objectListValueGroup) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var valueGroupItem in objectListValueGroup.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue(valueGroupItem); } } writer.WriteEndArray(); break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the StakeHolderValueMap"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not StakeHolderValueMap stakeHolderValueMap) + { + throw new ArgumentException("The thing shall be a StakeHolderValueMap", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of StakeHolderValueMap since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing StakeHolderValueMap for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in stakeHolderValueMap.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var categoryItem in stakeHolderValueMap.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(stakeHolderValueMap.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in stakeHolderValueMap.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var excludedDomainItem in stakeHolderValueMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "goal": - if(!AllowedVersionsPerProperty["goal"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in stakeHolderValueMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WriteStartArray("goal"u8); - if(value is IEnumerable objectListGoal) + foreach(var goalItem in stakeHolderValueMap.Goal.OrderBy(x => x, this.GuidComparer)) { - foreach(var goalItem in objectListGoal.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(goalItem); - } + writer.WriteStringValue(goalItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in stakeHolderValueMap.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(stakeHolderValueMap.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(stakeHolderValueMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(stakeHolderValueMap.Name); + writer.WriteStartArray("requirement"u8); + + foreach(var requirementItem in stakeHolderValueMap.Requirement.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(requirementItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(stakeHolderValueMap.RevisionNumber); + writer.WriteStartArray("settings"u8); + + foreach(var settingsItem in stakeHolderValueMap.Settings.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(settingsItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(stakeHolderValueMap.ShortName); + writer.WriteStartArray("stakeholderValue"u8); + + foreach(var stakeholderValueItem in stakeHolderValueMap.StakeholderValue.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(stakeholderValueItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WriteStartArray("valueGroup"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var valueGroupItem in stakeHolderValueMap.ValueGroup.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(valueGroupItem); } - + writer.WriteEndArray(); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing StakeHolderValueMap for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in stakeHolderValueMap.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("iid"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in stakeHolderValueMap.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(stakeHolderValueMap.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in stakeHolderValueMap.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in stakeHolderValueMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in stakeHolderValueMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("goal"u8); + + foreach(var goalItem in stakeHolderValueMap.Goal.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(goalItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in stakeHolderValueMap.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(stakeHolderValueMap.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(stakeHolderValueMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteStringValue(stakeHolderValueMap.Name); + writer.WriteStartArray("requirement"u8); + + foreach(var requirementItem in stakeHolderValueMap.Requirement.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(requirementItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(stakeHolderValueMap.RevisionNumber); + writer.WriteStartArray("settings"u8); + + foreach(var settingsItem in stakeHolderValueMap.Settings.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(settingsItem); } - break; - case "requirement": - if(!AllowedVersionsPerProperty["requirement"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(stakeHolderValueMap.ShortName); + writer.WriteStartArray("stakeholderValue"u8); + + foreach(var stakeholderValueItem in stakeHolderValueMap.StakeholderValue.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(stakeholderValueItem); } - writer.WriteStartArray("requirement"u8); + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(stakeHolderValueMap.ThingPreference); + writer.WriteStartArray("valueGroup"u8); - if(value is IEnumerable objectListRequirement) + foreach(var valueGroupItem in stakeHolderValueMap.ValueGroup.OrderBy(x => x, this.GuidComparer)) { - foreach(var requirementItem in objectListRequirement.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(requirementItem); - } + writer.WriteStringValue(valueGroupItem); } - + writer.WriteEndArray(); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing StakeHolderValueMap for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(stakeHolderValueMap.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(stakeHolderValueMap.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "settings": - if(!AllowedVersionsPerProperty["settings"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in stakeHolderValueMap.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WriteStartArray("settings"u8); + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); - if(value is IEnumerable objectListSettings) + foreach(var categoryItem in stakeHolderValueMap.Category.OrderBy(x => x, this.GuidComparer)) { - foreach(var settingsItem in objectListSettings.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(settingsItem); - } + writer.WriteStringValue(categoryItem); } - + writer.WriteEndArray(); - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(stakeHolderValueMap.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) + foreach(var definitionItem in stakeHolderValueMap.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in stakeHolderValueMap.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "stakeholdervalue": - if(!AllowedVersionsPerProperty["stakeholderValue"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in stakeHolderValueMap.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WriteStartArray("stakeholderValue"u8); + writer.WriteEndArray(); + writer.WriteStartArray("goal"u8); - if(value is IEnumerable objectListStakeholderValue) + foreach(var goalItem in stakeHolderValueMap.Goal.OrderBy(x => x, this.GuidComparer)) { - foreach(var stakeholderValueItem in objectListStakeholderValue.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(stakeholderValueItem); - } + writer.WriteStringValue(goalItem); } - + writer.WriteEndArray(); - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in stakeHolderValueMap.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(stakeHolderValueMap.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(stakeHolderValueMap.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(stakeHolderValueMap.Name); + writer.WriteStartArray("requirement"u8); + + foreach(var requirementItem in stakeHolderValueMap.Requirement.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(requirementItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(stakeHolderValueMap.RevisionNumber); + writer.WriteStartArray("settings"u8); + + foreach(var settingsItem in stakeHolderValueMap.Settings.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(settingsItem); } - break; - case "valuegroup": - if(!AllowedVersionsPerProperty["valueGroup"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(stakeHolderValueMap.ShortName); + writer.WriteStartArray("stakeholderValue"u8); + + foreach(var stakeholderValueItem in stakeHolderValueMap.StakeholderValue.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(stakeholderValueItem); } + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(stakeHolderValueMap.ThingPreference); writer.WriteStartArray("valueGroup"u8); - if(value is IEnumerable objectListValueGroup) + foreach(var valueGroupItem in stakeHolderValueMap.ValueGroup.OrderBy(x => x, this.GuidComparer)) { - foreach(var valueGroupItem in objectListValueGroup.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(valueGroupItem); - } + writer.WriteStringValue(valueGroupItem); } - + writer.WriteEndArray(); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the StakeHolderValueMap"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "goal", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "requirement", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "settings", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "stakeholderValue", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "valueGroup", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/StakeHolderValueMapSettingsSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/StakeHolderValueMapSettingsSerializer.cs index 9a0ecc24..5d461270 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/StakeHolderValueMapSettingsSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/StakeHolderValueMapSettingsSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,6 +49,296 @@ namespace CDP4JsonSerializer /// public class StakeHolderValueMapSettingsSerializer : BaseThingSerializer, IThingSerializer { + /// + /// Serialize a value for a property into a + /// + /// The name of the property to serialize + /// The object value to serialize + /// The + /// The that has been requested for the serialization + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + var requestedVersion = requestedDataModelVersion.ToString(3); + + switch(propertyName.ToLower()) + { + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("classKind"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } + + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } + + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + + writer.WriteEndArray(); + break; + case "goaltovaluegrouprelationship": + var allowedVersionsForGoalToValueGroupRelationship = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForGoalToValueGroupRelationship.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("goalToValueGroupRelationship"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("revisionNumber"u8); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "stakeholdervaluetorequirementrelationship": + var allowedVersionsForStakeholderValueToRequirementRelationship = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStakeholderValueToRequirementRelationship.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("stakeholderValueToRequirementRelationship"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("thingPreference"u8); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "valuegrouptostakeholdervaluerelationship": + var allowedVersionsForValueGroupToStakeholderValueRelationship = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValueGroupToStakeholderValueRelationship.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("valueGroupToStakeholderValueRelationship"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the StakeHolderValueMapSettings"); + } + } + /// /// Serializes a into an /// @@ -76,7 +365,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM switch(requestedDataModelVersion.ToString(3)) { case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing StakeHolderValueMapSettings for Version 1.1.0"); + Logger.Log(LogLevel.Debug, "Serializing StakeHolderValueMapSettings for Version 1.1.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(stakeHolderValueMapSettings.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -87,7 +376,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in stakeHolderValueMapSettings.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -96,7 +384,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("goalToValueGroupRelationship"u8); if(stakeHolderValueMapSettings.GoalToValueGroupRelationship.HasValue) @@ -138,7 +425,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM break; case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing StakeHolderValueMapSettings for Version 1.2.0"); + Logger.Log(LogLevel.Debug, "Serializing StakeHolderValueMapSettings for Version 1.2.0"); writer.WritePropertyName("classKind"u8); writer.WriteStringValue(stakeHolderValueMapSettings.ClassKind.ToString()); writer.WriteStartArray("excludedDomain"u8); @@ -149,7 +436,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in stakeHolderValueMapSettings.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -158,7 +444,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("goalToValueGroupRelationship"u8); if(stakeHolderValueMapSettings.GoalToValueGroupRelationship.HasValue) @@ -202,7 +487,7 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM break; case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing StakeHolderValueMapSettings for Version 1.3.0"); + Logger.Log(LogLevel.Debug, "Serializing StakeHolderValueMapSettings for Version 1.3.0"); writer.WritePropertyName("actor"u8); if(stakeHolderValueMapSettings.Actor.HasValue) @@ -224,7 +509,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in stakeHolderValueMapSettings.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -233,7 +517,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("goalToValueGroupRelationship"u8); if(stakeHolderValueMapSettings.GoalToValueGroupRelationship.HasValue) @@ -282,241 +565,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteEndObject(); } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("actor"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) - { - return; - } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "goaltovaluegrouprelationship": - if(!AllowedVersionsPerProperty["goalToValueGroupRelationship"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("goalToValueGroupRelationship"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "stakeholdervaluetorequirementrelationship": - if(!AllowedVersionsPerProperty["stakeholderValueToRequirementRelationship"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("stakeholderValueToRequirementRelationship"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "valuegrouptostakeholdervaluerelationship": - if(!AllowedVersionsPerProperty["valueGroupToStakeholderValueRelationship"].Contains(requestedVersion)) - { - return; - } - - writer.WritePropertyName("valueGroupToStakeholderValueRelationship"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the StakeHolderValueMapSettings"); - } - } - - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "goalToValueGroupRelationship", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "stakeholderValueToRequirementRelationship", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "valueGroupToStakeholderValueRelationship", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - }; } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/StakeholderSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/StakeholderSerializer.cs index 4e34a488..fcde18fc 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/StakeholderSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/StakeholderSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,311 +50,334 @@ namespace CDP4JsonSerializer public class StakeholderSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not Stakeholder stakeholder) - { - throw new ArgumentException("The thing shall be a Stakeholder", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of Stakeholder since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Stakeholder for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in stakeholder.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in stakeholder.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(stakeholder.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in stakeholder.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("alias"u8); - foreach(var excludedDomainItem in stakeholder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(excludedDomainItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "category": + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in stakeholder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("category"u8); - foreach(var hyperLinkItem in stakeholder.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(hyperLinkItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(stakeholder.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(stakeholder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(stakeholder.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(stakeholder.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(stakeholder.ShortName); - writer.WriteStartArray("stakeholderValue"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var stakeholderValueItem in stakeholder.StakeholderValue.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(stakeholderValueItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } + break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Stakeholder for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "definition": + var allowedVersionsForDefinition = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in stakeholder.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("definition"u8); - foreach(var categoryItem in stakeholder.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(categoryItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(stakeholder.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in stakeholder.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); - foreach(var excludedDomainItem in stakeholder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in stakeholder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var hyperLinkItem in stakeholder.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(hyperLinkItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(stakeholder.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(stakeholder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(stakeholder.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(stakeholder.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(stakeholder.ShortName); - writer.WriteStartArray("stakeholderValue"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var stakeholderValueItem in stakeholder.StakeholderValue.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(stakeholderValueItem); + return; } - writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(stakeholder.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Stakeholder for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(stakeholder.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(stakeholder.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in stakeholder.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in stakeholder.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(stakeholder.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + break; + case "name": + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in stakeholder.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForName.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("name"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in stakeholder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in stakeholder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedPersonItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in stakeholder.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(stakeholder.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(stakeholder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(stakeholder.Name); writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(stakeholder.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(stakeholder.ShortName); - writer.WriteStartArray("stakeholderValue"u8); - - foreach(var stakeholderValueItem in stakeholder.StakeholderValue.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(stakeholderValueItem); + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(stakeholder.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "shortname": + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -363,53 +385,48 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "stakeholdervalue": + var allowedVersionsForStakeholderValue = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(!allowedVersionsForStakeholderValue.Contains(requestedVersion)) { return; } - writer.WriteStartArray("category"u8); + writer.WriteStartArray("stakeholderValue"u8); - if(value is IEnumerable objectListCategory) + if(value is IEnumerable objectListStakeholderValue) { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + foreach(var stakeholderValueItem in objectListStakeholderValue.OfType().OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue(stakeholderValueItem); } } writer.WriteEndArray(); break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -417,230 +434,270 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the Stakeholder"); + } + } - writer.WriteStartArray("definition"u8); + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not Stakeholder stakeholder) + { + throw new ArgumentException("The thing shall be a Stakeholder", nameof(thing)); + } - if(value is IEnumerable objectListDefinition) + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Stakeholder since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Stakeholder for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in stakeholder.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in stakeholder.Category.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(categoryItem); } - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(stakeholder.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListExcludedDomain) + foreach(var definitionItem in stakeholder.Definition.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteStringValue(definitionItem); } - + writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in stakeholder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) + foreach(var excludedPersonItem in stakeholder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue(excludedPersonItem); } - + writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in stakeholder.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(stakeholder.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(stakeholder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(stakeholder.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(stakeholder.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(stakeholder.ShortName); + writer.WriteStartArray("stakeholderValue"u8); - if(value is IEnumerable objectListHyperLink) + foreach(var stakeholderValueItem in stakeholder.StakeholderValue.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(stakeholderValueItem); } - + writer.WriteEndArray(); break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Stakeholder for Version 1.2.0"); + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + foreach(var aliasItem in stakeholder.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in stakeholder.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(stakeholder.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in stakeholder.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in stakeholder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in stakeholder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in stakeholder.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(stakeholder.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(stakeholder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else + writer.WriteStringValue(stakeholder.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(stakeholder.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(stakeholder.ShortName); + writer.WriteStartArray("stakeholderValue"u8); + + foreach(var stakeholderValueItem in stakeholder.StakeholderValue.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(stakeholderValueItem); } + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(stakeholder.ThingPreference); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Stakeholder for Version 1.3.0"); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + if(stakeholder.Actor.HasValue) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(stakeholder.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("alias"u8); - writer.WritePropertyName("shortName"u8); - - if(value != null) + foreach(var aliasItem in stakeholder.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in stakeholder.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "stakeholdervalue": - if(!AllowedVersionsPerProperty["stakeholderValue"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(stakeholder.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in stakeholder.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WriteStartArray("stakeholderValue"u8); + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListStakeholderValue) + foreach(var excludedDomainItem in stakeholder.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - foreach(var stakeholderValueItem in objectListStakeholderValue.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(stakeholderValueItem); - } + writer.WriteStringValue(excludedDomainItem); } - + writer.WriteEndArray(); - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in stakeholder.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in stakeholder.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(hyperLinkItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(stakeholder.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(stakeholder.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(stakeholder.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(stakeholder.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(stakeholder.ShortName); + writer.WriteStartArray("stakeholderValue"u8); + + foreach(var stakeholderValueItem in stakeholder.StakeholderValue.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(stakeholderValueItem); } + writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(stakeholder.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the Stakeholder"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "stakeholderValue", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/StakeholderValueSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/StakeholderValueSerializer.cs index 5279e8a3..7a7afb84 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/StakeholderValueSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/StakeholderValueSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,260 +49,6 @@ namespace CDP4JsonSerializer /// public class StakeholderValueSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not StakeholderValue stakeholderValue) - { - throw new ArgumentException("The thing shall be a StakeholderValue", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of StakeholderValue since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing StakeholderValue for Version 1.1.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in stakeholderValue.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in stakeholderValue.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(stakeholderValue.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in stakeholderValue.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in stakeholderValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in stakeholderValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in stakeholderValue.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(stakeholderValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(stakeholderValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(stakeholderValue.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(stakeholderValue.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(stakeholderValue.ShortName); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing StakeholderValue for Version 1.2.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in stakeholderValue.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in stakeholderValue.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(stakeholderValue.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in stakeholderValue.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in stakeholderValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in stakeholderValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in stakeholderValue.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(stakeholderValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(stakeholderValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(stakeholderValue.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(stakeholderValue.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(stakeholderValue.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(stakeholderValue.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing StakeholderValue for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(stakeholderValue.Actor.HasValue) - { - writer.WriteStringValue(stakeholderValue.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in stakeholderValue.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in stakeholderValue.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(stakeholderValue.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in stakeholderValue.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in stakeholderValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in stakeholderValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in stakeholderValue.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(stakeholderValue.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(stakeholderValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(stakeholderValue.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(stakeholderValue.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(stakeholderValue.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(stakeholderValue.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -311,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -319,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -337,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + var allowedVersionsForAlias = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) { return; } @@ -355,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) { return; } @@ -373,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -391,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + var allowedVersionsForDefinition = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { return; } @@ -409,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -427,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -445,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + var allowedVersionsForHyperLink = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { return; } @@ -463,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -481,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -499,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -517,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -535,7 +361,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -553,7 +386,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -576,25 +415,240 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not StakeholderValue stakeholderValue) + { + throw new ArgumentException("The thing shall be a StakeholderValue", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of StakeholderValue since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing StakeholderValue for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in stakeholderValue.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in stakeholderValue.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(stakeholderValue.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in stakeholderValue.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in stakeholderValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in stakeholderValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in stakeholderValue.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(stakeholderValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(stakeholderValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(stakeholderValue.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(stakeholderValue.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(stakeholderValue.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing StakeholderValue for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in stakeholderValue.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in stakeholderValue.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(stakeholderValue.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in stakeholderValue.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in stakeholderValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in stakeholderValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in stakeholderValue.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(stakeholderValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(stakeholderValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(stakeholderValue.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(stakeholderValue.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(stakeholderValue.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(stakeholderValue.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing StakeholderValue for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(stakeholderValue.Actor.HasValue) + { + writer.WriteStringValue(stakeholderValue.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in stakeholderValue.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in stakeholderValue.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(stakeholderValue.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in stakeholderValue.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in stakeholderValue.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in stakeholderValue.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in stakeholderValue.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(stakeholderValue.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(stakeholderValue.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(stakeholderValue.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(stakeholderValue.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(stakeholderValue.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(stakeholderValue.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/TelephoneNumberSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/TelephoneNumberSerializer.cs index edd1133a..028bdf06 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/TelephoneNumberSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/TelephoneNumberSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,193 +49,6 @@ namespace CDP4JsonSerializer /// public class TelephoneNumberSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not TelephoneNumber telephoneNumber) - { - throw new ArgumentException("The thing shall be a TelephoneNumber", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of TelephoneNumber since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing TelephoneNumber for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(telephoneNumber.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(telephoneNumber.Iid); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(telephoneNumber.RevisionNumber); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(telephoneNumber.Value); - writer.WriteStartArray("vcardType"u8); - - foreach(var vcardTypeItem in telephoneNumber.VcardType) - { - writer.WriteStringValue(vcardTypeItem.ToString()); - } - - writer.WriteEndArray(); - - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing TelephoneNumber for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(telephoneNumber.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in telephoneNumber.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in telephoneNumber.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(telephoneNumber.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(telephoneNumber.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(telephoneNumber.RevisionNumber); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(telephoneNumber.Value); - writer.WriteStartArray("vcardType"u8); - - foreach(var vcardTypeItem in telephoneNumber.VcardType) - { - writer.WriteStringValue(vcardTypeItem.ToString()); - } - - writer.WriteEndArray(); - - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing TelephoneNumber for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(telephoneNumber.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in telephoneNumber.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in telephoneNumber.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(telephoneNumber.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(telephoneNumber.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(telephoneNumber.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(telephoneNumber.ThingPreference); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(telephoneNumber.Value); - writer.WriteStartArray("vcardType"u8); - - foreach(var vcardTypeItem in telephoneNumber.VcardType) - { - writer.WriteStringValue(vcardTypeItem.ToString()); - } - - writer.WriteEndArray(); - - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing TelephoneNumber for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(telephoneNumber.Actor.HasValue) - { - writer.WriteStringValue(telephoneNumber.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(telephoneNumber.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in telephoneNumber.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in telephoneNumber.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(telephoneNumber.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(telephoneNumber.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(telephoneNumber.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(telephoneNumber.ThingPreference); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(telephoneNumber.Value); - writer.WriteStartArray("vcardType"u8); - - foreach(var vcardTypeItem in telephoneNumber.VcardType) - { - writer.WriteStringValue(vcardTypeItem.ToString()); - } - - writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -244,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -252,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -270,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -288,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -306,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -324,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -342,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -360,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -378,7 +239,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -396,7 +263,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "value": - if(!AllowedVersionsPerProperty["value"].Contains(requestedVersion)) + var allowedVersionsForValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValue.Contains(requestedVersion)) { return; } @@ -414,7 +289,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "vcardtype": - if(!AllowedVersionsPerProperty["vcardType"].Contains(requestedVersion)) + var allowedVersionsForVcardType = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForVcardType.Contains(requestedVersion)) { return; } @@ -437,21 +320,181 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "value", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "vcardType", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not TelephoneNumber telephoneNumber) + { + throw new ArgumentException("The thing shall be a TelephoneNumber", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of TelephoneNumber since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing TelephoneNumber for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(telephoneNumber.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(telephoneNumber.Iid); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(telephoneNumber.RevisionNumber); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(telephoneNumber.Value); + writer.WriteStartArray("vcardType"u8); + + foreach(var vcardTypeItem in telephoneNumber.VcardType) + { + writer.WriteStringValue(vcardTypeItem.ToString()); + } + + writer.WriteEndArray(); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing TelephoneNumber for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(telephoneNumber.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in telephoneNumber.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in telephoneNumber.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(telephoneNumber.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(telephoneNumber.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(telephoneNumber.RevisionNumber); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(telephoneNumber.Value); + writer.WriteStartArray("vcardType"u8); + + foreach(var vcardTypeItem in telephoneNumber.VcardType) + { + writer.WriteStringValue(vcardTypeItem.ToString()); + } + + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing TelephoneNumber for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(telephoneNumber.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in telephoneNumber.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in telephoneNumber.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(telephoneNumber.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(telephoneNumber.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(telephoneNumber.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(telephoneNumber.ThingPreference); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(telephoneNumber.Value); + writer.WriteStartArray("vcardType"u8); + + foreach(var vcardTypeItem in telephoneNumber.VcardType) + { + writer.WriteStringValue(vcardTypeItem.ToString()); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing TelephoneNumber for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(telephoneNumber.Actor.HasValue) + { + writer.WriteStringValue(telephoneNumber.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(telephoneNumber.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in telephoneNumber.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in telephoneNumber.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(telephoneNumber.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(telephoneNumber.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(telephoneNumber.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(telephoneNumber.ThingPreference); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(telephoneNumber.Value); + writer.WriteStartArray("vcardType"u8); + + foreach(var vcardTypeItem in telephoneNumber.VcardType) + { + writer.WriteStringValue(vcardTypeItem.ToString()); + } + + writer.WriteEndArray(); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/TermSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/TermSerializer.cs index 00c4ad37..14e1340b 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/TermSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/TermSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,112 +50,424 @@ namespace CDP4JsonSerializer public class TermSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not Term term) - { - throw new ArgumentException("The thing shall be a Term", nameof(thing)); - } + var requestedVersion = requestedDataModelVersion.ToString(3); - if (requestedDataModelVersion < Version.Parse("1.0.0")) + switch(propertyName.ToLower()) { - Logger.Log(LogLevel.Info, "Skipping serialization of Term since Version is below 1.0.0"); - return; - } + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - writer.WriteStartObject(); + if(!allowedVersionsForActor.Contains(requestedVersion)) + { + return; + } - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing Term for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + writer.WritePropertyName("actor"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var aliasItem in term.Alias.OrderBy(x => x, this.GuidComparer)) + break; + case "alias": + var allowedVersionsForAlias = new List { - writer.WriteStringValue(aliasItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WriteStartArray("alias"u8); + + if(value is IEnumerable objectListAlias) + { + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + } + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(term.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + + if(value != null) + { + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); + } - foreach(var definitionItem in term.Definition.OrderBy(x => x, this.GuidComparer)) + break; + case "definition": + var allowedVersionsForDefinition = new List { - writer.WriteStringValue(definitionItem); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefinition.Contains(requestedVersion)) + { + return; } + writer.WriteStartArray("definition"u8); + + if(value is IEnumerable objectListDefinition) + { + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + } + writer.WriteEndArray(); + break; + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("excludedDomain"u8); + + if(value is IEnumerable objectListExcludedDomain) + { + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + } - writer.WriteStartArray("hyperLink"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var hyperLinkItem in term.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(hyperLinkItem); + return; } + writer.WriteStartArray("excludedPerson"u8); + + if(value is IEnumerable objectListExcludedPerson) + { + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + } + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) + { + return; + } + + writer.WriteStartArray("hyperLink"u8); + + if(value is IEnumerable objectListHyperLink) + { + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + } + writer.WriteEndArray(); + break; + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("iid"u8); - writer.WriteStringValue(term.Iid); + + if(value != null) + { + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(term.IsDeprecated); + + if(value != null) + { + writer.WriteBooleanValue((bool)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) + { + return; + } + + writer.WritePropertyName("modifiedOn"u8); + + if(value != null) + { + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + break; + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("name"u8); - writer.WriteStringValue(term.Name); + + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } + + break; + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) + { + return; + } + writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(term.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(term.ShortName); + + if(value != null) + { + writer.WriteNumberValue((int)value); + } + else + { + writer.WriteNullValue(); + } + break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing Term for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in term.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForShortName.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("shortName"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(term.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var definitionItem in term.Definition.OrderBy(x => x, this.GuidComparer)) + break; + case "thingpreference": + var allowedVersionsForThingPreference = new List { - writer.WriteStringValue(definitionItem); + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) + { + return; } - writer.WriteEndArray(); + writer.WritePropertyName("thingPreference"u8); - writer.WriteStartArray("excludedDomain"u8); + if(value != null) + { + writer.WriteStringValue((string)value); + } + else + { + writer.WriteNullValue(); + } - foreach(var excludedDomainItem in term.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the Term"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not Term term) + { + throw new ArgumentException("The thing shall be a Term", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of Term since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing Term for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in term.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(aliasItem); } writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(term.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); - foreach(var excludedPersonItem in term.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + foreach(var definitionItem in term.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(definitionItem); } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in term.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -165,13 +476,10 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(term.Iid); writer.WritePropertyName("isDeprecated"u8); writer.WriteBooleanValue(term.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(term.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); writer.WriteStringValue(term.Name); writer.WritePropertyName("revisionNumber"u8); @@ -179,8 +487,8 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WritePropertyName("shortName"u8); writer.WriteStringValue(term.ShortName); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing Term for Version 1.2.0"); + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing Term for Version 1.1.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in term.Alias.OrderBy(x => x, this.GuidComparer)) @@ -189,7 +497,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(term.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -200,7 +507,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in term.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -209,7 +515,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in term.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -218,7 +523,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in term.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -227,7 +531,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(term.Iid); writer.WritePropertyName("isDeprecated"u8); @@ -240,22 +543,9 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WriteNumberValue(term.RevisionNumber); writer.WritePropertyName("shortName"u8); writer.WriteStringValue(term.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(term.ThingPreference); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing Term for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(term.Actor.HasValue) - { - writer.WriteStringValue(term.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing Term for Version 1.2.0"); writer.WriteStartArray("alias"u8); foreach(var aliasItem in term.Alias.OrderBy(x => x, this.GuidComparer)) @@ -264,7 +554,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); writer.WriteStringValue(term.ClassKind.ToString()); writer.WriteStartArray("definition"u8); @@ -275,7 +564,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); foreach(var excludedDomainItem in term.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) @@ -284,7 +572,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); foreach(var excludedPersonItem in term.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) @@ -293,7 +580,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); foreach(var hyperLinkItem in term.HyperLink.OrderBy(x => x, this.GuidComparer)) @@ -302,7 +588,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM } writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); writer.WriteStringValue(term.Iid); writer.WritePropertyName("isDeprecated"u8); @@ -318,304 +603,82 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM writer.WritePropertyName("thingPreference"u8); writer.WriteStringValue(term.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); - - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) - { - return; - } - + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing Term for Version 1.3.0"); writer.WritePropertyName("actor"u8); - - if(value != null) + + if(term.Actor.HasValue) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(term.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) - { - return; - } - writer.WriteStartArray("alias"u8); - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + foreach(var aliasItem in term.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } + writer.WriteEndArray(); writer.WritePropertyName("classKind"u8); - - if(value != null) - { - writer.WriteStringValue(((ClassKind)value).ToString()); - } - else - { - writer.WriteNullValue(); - } - - break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(term.ClassKind.ToString()); writer.WriteStartArray("definition"u8); - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + foreach(var definitionItem in term.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedDomain"u8); - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } - - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + foreach(var excludedDomainItem in term.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } + writer.WriteEndArray(); writer.WriteStartArray("excludedPerson"u8); - if(value is IEnumerable objectListExcludedPerson) - { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + foreach(var excludedPersonItem in term.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); writer.WriteStartArray("hyperLink"u8); - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + foreach(var hyperLinkItem in term.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); writer.WritePropertyName("iid"u8); - - if(value != null) - { - writer.WriteStringValue((Guid)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(term.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) - { - writer.WriteBooleanValue((bool)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) - { - return; - } - + writer.WriteBooleanValue(term.IsDeprecated); writer.WritePropertyName("modifiedOn"u8); - - if(value != null) - { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(term.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(term.Name); writer.WritePropertyName("revisionNumber"u8); - - if(value != null) - { - writer.WriteNumberValue((int)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) - { - return; - } - + writer.WriteNumberValue(term.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) - { - return; - } - + writer.WriteStringValue(term.ShortName); writer.WritePropertyName("thingPreference"u8); - - if(value != null) - { - writer.WriteStringValue((string)value); - } - else - { - writer.WriteNullValue(); - } - + writer.WriteStringValue(term.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the Term"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/TextParameterTypeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/TextParameterTypeSerializer.cs index daafd885..9c1d0716 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/TextParameterTypeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/TextParameterTypeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,349 +50,317 @@ namespace CDP4JsonSerializer public class TextParameterTypeSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not TextParameterType textParameterType) - { - throw new ArgumentException("The thing shall be a TextParameterType", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of TextParameterType since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing TextParameterType for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in textParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in textParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(textParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in textParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in textParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(textParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(textParameterType.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(textParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(textParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(textParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(textParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing TextParameterType for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in textParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in textParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(textParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in textParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in textParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in textParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in textParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(textParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(textParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(textParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(textParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(textParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(textParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(textParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing TextParameterType for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in textParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in textParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(textParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in textParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in textParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in textParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in textParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(textParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(textParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(textParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(textParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(textParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(textParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(textParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(textParameterType.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing TextParameterType for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(textParameterType.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(textParameterType.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in textParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in textParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(textParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in textParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in textParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in textParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in textParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(textParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(textParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(textParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(textParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(textParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(textParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(textParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(textParameterType.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -401,53 +368,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + return; } + + writer.WritePropertyName("revisionNumber"u8); - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteNumberValue((int)value); } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + else { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -455,249 +420,357 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "symbol": + var allowedVersionsForSymbol = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + return; } + + writer.WritePropertyName("symbol"u8); - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) + else { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("hyperLink"u8); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the TextParameterType"); + } + } - if(value is IEnumerable objectListHyperLink) + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not TextParameterType textParameterType) + { + throw new ArgumentException("The thing shall be a TextParameterType", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of TextParameterType since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing TextParameterType for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in textParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("category"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + foreach(var categoryItem in textParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(textParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in textParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in textParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(textParameterType.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteBooleanValue(textParameterType.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(textParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(textParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(textParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(textParameterType.Symbol); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing TextParameterType for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in textParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in textParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(textParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in textParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in textParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in textParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in textParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(textParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(textParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(textParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteStringValue(textParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(textParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(textParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(textParameterType.Symbol); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing TextParameterType for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in textParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in textParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(textParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in textParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in textParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in textParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in textParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(textParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(textParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(textParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(textParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(textParameterType.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(textParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(textParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(textParameterType.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing TextParameterType for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(textParameterType.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(textParameterType.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in textParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("symbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in textParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(textParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in textParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in textParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in textParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in textParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(textParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(textParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(textParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(textParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(textParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(textParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(textParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(textParameterType.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the TextParameterType"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/TextualNoteSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/TextualNoteSerializer.cs index 132af6d3..168f2403 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/TextualNoteSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/TextualNoteSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,203 +49,6 @@ namespace CDP4JsonSerializer /// public class TextualNoteSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not TextualNote textualNote) - { - throw new ArgumentException("The thing shall be a TextualNote", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of TextualNote since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing TextualNote for Version 1.1.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in textualNote.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(textualNote.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(textualNote.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(textualNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in textualNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in textualNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(textualNote.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(textualNote.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(textualNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(textualNote.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(textualNote.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(textualNote.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(textualNote.ShortName); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing TextualNote for Version 1.2.0"); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in textualNote.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(textualNote.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(textualNote.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(textualNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in textualNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in textualNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(textualNote.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(textualNote.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(textualNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(textualNote.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(textualNote.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(textualNote.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(textualNote.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(textualNote.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing TextualNote for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(textualNote.Actor.HasValue) - { - writer.WriteStringValue(textualNote.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in textualNote.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(textualNote.ClassKind.ToString()); - writer.WritePropertyName("content"u8); - writer.WriteStringValue(textualNote.Content); - writer.WritePropertyName("createdOn"u8); - writer.WriteStringValue(textualNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in textualNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in textualNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(textualNote.Iid); - writer.WritePropertyName("languageCode"u8); - writer.WriteStringValue(textualNote.LanguageCode); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(textualNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(textualNote.Name); - writer.WritePropertyName("owner"u8); - writer.WriteStringValue(textualNote.Owner); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(textualNote.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(textualNote.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(textualNote.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -254,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -262,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -280,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) { return; } @@ -298,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -316,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "content": - if(!AllowedVersionsPerProperty["content"].Contains(requestedVersion)) + var allowedVersionsForContent = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForContent.Contains(requestedVersion)) { return; } @@ -334,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "createdon": - if(!AllowedVersionsPerProperty["createdOn"].Contains(requestedVersion)) + var allowedVersionsForCreatedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCreatedOn.Contains(requestedVersion)) { return; } @@ -352,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -370,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -388,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -406,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "languagecode": - if(!AllowedVersionsPerProperty["languageCode"].Contains(requestedVersion)) + var allowedVersionsForLanguageCode = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForLanguageCode.Contains(requestedVersion)) { return; } @@ -424,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -442,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -460,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "owner": - if(!AllowedVersionsPerProperty["owner"].Contains(requestedVersion)) + var allowedVersionsForOwner = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForOwner.Contains(requestedVersion)) { return; } @@ -478,7 +361,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -496,7 +386,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -514,7 +411,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -537,26 +440,192 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "content", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "createdOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "languageCode", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "owner", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not TextualNote textualNote) + { + throw new ArgumentException("The thing shall be a TextualNote", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of TextualNote since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing TextualNote for Version 1.1.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in textualNote.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(textualNote.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(textualNote.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(textualNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in textualNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in textualNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(textualNote.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(textualNote.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(textualNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(textualNote.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(textualNote.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(textualNote.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(textualNote.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing TextualNote for Version 1.2.0"); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in textualNote.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(textualNote.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(textualNote.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(textualNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in textualNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in textualNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(textualNote.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(textualNote.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(textualNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(textualNote.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(textualNote.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(textualNote.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(textualNote.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(textualNote.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing TextualNote for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(textualNote.Actor.HasValue) + { + writer.WriteStringValue(textualNote.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in textualNote.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(textualNote.ClassKind.ToString()); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(textualNote.Content); + writer.WritePropertyName("createdOn"u8); + writer.WriteStringValue(textualNote.CreatedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in textualNote.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in textualNote.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(textualNote.Iid); + writer.WritePropertyName("languageCode"u8); + writer.WriteStringValue(textualNote.LanguageCode); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(textualNote.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(textualNote.Name); + writer.WritePropertyName("owner"u8); + writer.WriteStringValue(textualNote.Owner); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(textualNote.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(textualNote.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(textualNote.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/TimeOfDayParameterTypeSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/TimeOfDayParameterTypeSerializer.cs index aca7ec45..a2f051dc 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/TimeOfDayParameterTypeSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/TimeOfDayParameterTypeSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,349 +50,317 @@ namespace CDP4JsonSerializer public class TimeOfDayParameterTypeSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not TimeOfDayParameterType timeOfDayParameterType) - { - throw new ArgumentException("The thing shall be a TimeOfDayParameterType", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of TimeOfDayParameterType since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing TimeOfDayParameterType for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in timeOfDayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in timeOfDayParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteStringValue((Guid)value); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(timeOfDayParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + break; + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in timeOfDayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("alias"u8); - foreach(var hyperLinkItem in timeOfDayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(hyperLinkItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(timeOfDayParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(timeOfDayParameterType.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(timeOfDayParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(timeOfDayParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(timeOfDayParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(timeOfDayParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing TimeOfDayParameterType for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "category": + var allowedVersionsForCategory = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in timeOfDayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForCategory.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("category"u8); - foreach(var categoryItem in timeOfDayParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListCategory) { - writer.WriteStringValue(categoryItem); + foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(timeOfDayParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in timeOfDayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in timeOfDayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedDomainItem); + writer.WriteStringValue(((ClassKind)value).ToString()); + } + else + { + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in timeOfDayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in timeOfDayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(timeOfDayParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(timeOfDayParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(timeOfDayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(timeOfDayParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(timeOfDayParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(timeOfDayParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(timeOfDayParameterType.Symbol); + writer.WriteEndArray(); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing TimeOfDayParameterType for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in timeOfDayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var categoryItem in timeOfDayParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(categoryItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(timeOfDayParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in timeOfDayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in timeOfDayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in timeOfDayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in timeOfDayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(timeOfDayParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(timeOfDayParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(timeOfDayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(timeOfDayParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(timeOfDayParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(timeOfDayParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(timeOfDayParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(timeOfDayParameterType.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing TimeOfDayParameterType for Version 1.3.0"); - writer.WritePropertyName("actor"u8); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(timeOfDayParameterType.Actor.HasValue) + if(!allowedVersionsForIid.Contains(requestedVersion)) { - writer.WriteStringValue(timeOfDayParameterType.Actor.Value); + return; + } + + writer.WritePropertyName("iid"u8); + + if(value != null) + { + writer.WriteStringValue((Guid)value); } else { writer.WriteNullValue(); } - writer.WriteStartArray("alias"u8); + break; + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in timeOfDayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("isDeprecated"u8); - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in timeOfDayParameterType.Category.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(categoryItem); + writer.WriteBooleanValue((bool)value); } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(timeOfDayParameterType.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in timeOfDayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(definitionItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + break; + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in timeOfDayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("modifiedOn"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in timeOfDayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in timeOfDayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(timeOfDayParameterType.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(timeOfDayParameterType.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(timeOfDayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(timeOfDayParameterType.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(timeOfDayParameterType.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(timeOfDayParameterType.ShortName); - writer.WritePropertyName("symbol"u8); - writer.WriteStringValue(timeOfDayParameterType.Symbol); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(timeOfDayParameterType.ThingPreference); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "name": + var allowedVersionsForName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("name"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue((string)value); } else { @@ -401,53 +368,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } - - writer.WriteStartArray("alias"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListAlias) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } + return; } + + writer.WritePropertyName("revisionNumber"u8); - writer.WriteEndArray(); - break; - case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteNumberValue((int)value); } - - writer.WriteStartArray("category"u8); - - if(value is IEnumerable objectListCategory) + else { - foreach(var categoryItem in objectListCategory.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteStringValue((string)value); } else { @@ -455,249 +420,357 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "symbol": + var allowedVersionsForSymbol = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("definition"u8); - - if(value is IEnumerable objectListDefinition) + if(!allowedVersionsForSymbol.Contains(requestedVersion)) { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } + return; } + + writer.WritePropertyName("symbol"u8); - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) + else { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + writer.WritePropertyName("thingPreference"u8); + + if(value != null) { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + else { - return; + writer.WriteNullValue(); } - writer.WriteStartArray("hyperLink"u8); + break; + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the TimeOfDayParameterType"); + } + } - if(value is IEnumerable objectListHyperLink) + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not TimeOfDayParameterType timeOfDayParameterType) + { + throw new ArgumentException("The thing shall be a TimeOfDayParameterType", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of TimeOfDayParameterType since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing TimeOfDayParameterType for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in timeOfDayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } + writer.WriteStringValue(aliasItem); } - + writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) - { - return; - } + writer.WriteStartArray("category"u8); - writer.WritePropertyName("iid"u8); - - if(value != null) + foreach(var categoryItem in timeOfDayParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((Guid)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(timeOfDayParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in timeOfDayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in timeOfDayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(timeOfDayParameterType.Iid); writer.WritePropertyName("isDeprecated"u8); - - if(value != null) + writer.WriteBooleanValue(timeOfDayParameterType.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(timeOfDayParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(timeOfDayParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(timeOfDayParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(timeOfDayParameterType.Symbol); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing TimeOfDayParameterType for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in timeOfDayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in timeOfDayParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(timeOfDayParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in timeOfDayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("modifiedOn"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in timeOfDayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in timeOfDayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in timeOfDayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(timeOfDayParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(timeOfDayParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(timeOfDayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteStringValue(timeOfDayParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(timeOfDayParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(timeOfDayParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(timeOfDayParameterType.Symbol); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing TimeOfDayParameterType for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in timeOfDayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in timeOfDayParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(categoryItem); } - break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(timeOfDayParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in timeOfDayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(definitionItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in timeOfDayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(excludedDomainItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in timeOfDayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedPersonItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in timeOfDayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(timeOfDayParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(timeOfDayParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(timeOfDayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(timeOfDayParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(timeOfDayParameterType.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(timeOfDayParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(timeOfDayParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(timeOfDayParameterType.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing TimeOfDayParameterType for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(timeOfDayParameterType.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(timeOfDayParameterType.Actor.Value); } else { writer.WriteNullValue(); } - break; - case "symbol": - if(!AllowedVersionsPerProperty["symbol"].Contains(requestedVersion)) + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in timeOfDayParameterType.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("symbol"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in timeOfDayParameterType.Category.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(categoryItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(timeOfDayParameterType.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in timeOfDayParameterType.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in timeOfDayParameterType.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); } - writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in timeOfDayParameterType.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(excludedPersonItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in timeOfDayParameterType.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(timeOfDayParameterType.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(timeOfDayParameterType.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(timeOfDayParameterType.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(timeOfDayParameterType.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(timeOfDayParameterType.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(timeOfDayParameterType.ShortName); + writer.WritePropertyName("symbol"u8); + writer.WriteStringValue(timeOfDayParameterType.Symbol); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(timeOfDayParameterType.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the TimeOfDayParameterType"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "symbol", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/UnitFactorSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/UnitFactorSerializer.cs index 5e29c196..5e5c7268 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/UnitFactorSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/UnitFactorSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,165 +49,6 @@ namespace CDP4JsonSerializer /// public class UnitFactorSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not UnitFactor unitFactor) - { - throw new ArgumentException("The thing shall be a UnitFactor", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of UnitFactor since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing UnitFactor for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(unitFactor.ClassKind.ToString()); - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(unitFactor.Exponent); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(unitFactor.Iid); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(unitFactor.RevisionNumber); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(unitFactor.Unit); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing UnitFactor for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(unitFactor.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in unitFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in unitFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(unitFactor.Exponent); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(unitFactor.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(unitFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(unitFactor.RevisionNumber); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(unitFactor.Unit); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing UnitFactor for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(unitFactor.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in unitFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in unitFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(unitFactor.Exponent); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(unitFactor.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(unitFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(unitFactor.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(unitFactor.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(unitFactor.Unit); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing UnitFactor for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(unitFactor.Actor.HasValue) - { - writer.WriteStringValue(unitFactor.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(unitFactor.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in unitFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in unitFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("exponent"u8); - writer.WriteStringValue(unitFactor.Exponent); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(unitFactor.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(unitFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(unitFactor.RevisionNumber); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(unitFactor.ThingPreference); - writer.WritePropertyName("unit"u8); - writer.WriteStringValue(unitFactor.Unit); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -216,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -224,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -242,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -260,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -278,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -296,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "exponent": - if(!AllowedVersionsPerProperty["exponent"].Contains(requestedVersion)) + var allowedVersionsForExponent = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExponent.Contains(requestedVersion)) { return; } @@ -314,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -332,7 +214,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -350,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -368,7 +265,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -386,7 +289,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "unit": - if(!AllowedVersionsPerProperty["unit"].Contains(requestedVersion)) + var allowedVersionsForUnit = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForUnit.Contains(requestedVersion)) { return; } @@ -409,21 +320,157 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "exponent", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "unit", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not UnitFactor unitFactor) + { + throw new ArgumentException("The thing shall be a UnitFactor", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of UnitFactor since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing UnitFactor for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(unitFactor.ClassKind.ToString()); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(unitFactor.Exponent); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(unitFactor.Iid); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(unitFactor.RevisionNumber); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(unitFactor.Unit); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing UnitFactor for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(unitFactor.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in unitFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in unitFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(unitFactor.Exponent); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(unitFactor.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(unitFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(unitFactor.RevisionNumber); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(unitFactor.Unit); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing UnitFactor for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(unitFactor.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in unitFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in unitFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(unitFactor.Exponent); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(unitFactor.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(unitFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(unitFactor.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(unitFactor.ThingPreference); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(unitFactor.Unit); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing UnitFactor for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(unitFactor.Actor.HasValue) + { + writer.WriteStringValue(unitFactor.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(unitFactor.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in unitFactor.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in unitFactor.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("exponent"u8); + writer.WriteStringValue(unitFactor.Exponent); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(unitFactor.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(unitFactor.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(unitFactor.RevisionNumber); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(unitFactor.ThingPreference); + writer.WritePropertyName("unit"u8); + writer.WriteStringValue(unitFactor.Unit); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/UnitPrefixSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/UnitPrefixSerializer.cs index 9bed9933..dfbf4c97 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/UnitPrefixSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/UnitPrefixSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -51,309 +50,236 @@ namespace CDP4JsonSerializer public class UnitPrefixSerializer : BaseThingSerializer, IThingSerializer { /// - /// Serializes a into an + /// Serialize a value for a property into a /// - /// The that have to be serialized + /// The name of the property to serialize + /// The object value to serialize /// The /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { - if (thing is not UnitPrefix unitPrefix) - { - throw new ArgumentException("The thing shall be a UnitPrefix", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of UnitPrefix since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); + var requestedVersion = requestedDataModelVersion.ToString(3); - switch(requestedDataModelVersion.ToString(3)) + switch(propertyName.ToLower()) { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing UnitPrefix for Version 1.0.0"); - writer.WriteStartArray("alias"u8); + case "actor": + var allowedVersionsForActor = new List + { + "1.3.0", + }; - foreach(var aliasItem in unitPrefix.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForActor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("actor"u8); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(unitPrefix.ClassKind.ToString()); - writer.WritePropertyName("conversionFactor"u8); - writer.WriteStringValue(unitPrefix.ConversionFactor); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in unitPrefix.Definition.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((Guid)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in unitPrefix.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(unitPrefix.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(unitPrefix.IsDeprecated); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(unitPrefix.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(unitPrefix.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(unitPrefix.ShortName); break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing UnitPrefix for Version 1.1.0"); - writer.WriteStartArray("alias"u8); + case "alias": + var allowedVersionsForAlias = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in unitPrefix.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForAlias.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(unitPrefix.ClassKind.ToString()); - writer.WritePropertyName("conversionFactor"u8); - writer.WriteStringValue(unitPrefix.ConversionFactor); - writer.WriteStartArray("definition"u8); + writer.WriteStartArray("alias"u8); - foreach(var definitionItem in unitPrefix.Definition.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListAlias) { - writer.WriteStringValue(definitionItem); + foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedDomain"u8); + writer.WriteEndArray(); + break; + case "classkind": + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedDomainItem in unitPrefix.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { - writer.WriteStringValue(excludedDomainItem); + return; } - writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in unitPrefix.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(value != null) { - writer.WriteStringValue(excludedPersonItem); + writer.WriteStringValue(((ClassKind)value).ToString()); } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in unitPrefix.HyperLink.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(hyperLinkItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(unitPrefix.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(unitPrefix.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(unitPrefix.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(unitPrefix.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(unitPrefix.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(unitPrefix.ShortName); break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing UnitPrefix for Version 1.2.0"); - writer.WriteStartArray("alias"u8); + case "conversionfactor": + var allowedVersionsForConversionFactor = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var aliasItem in unitPrefix.Alias.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForConversionFactor.Contains(requestedVersion)) { - writer.WriteStringValue(aliasItem); + return; } - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(unitPrefix.ClassKind.ToString()); writer.WritePropertyName("conversionFactor"u8); - writer.WriteStringValue(unitPrefix.ConversionFactor); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in unitPrefix.Definition.OrderBy(x => x, this.GuidComparer)) + + if(value != null) { - writer.WriteStringValue(definitionItem); + writer.WriteStringValue((string)value); } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in unitPrefix.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + else { - writer.WriteStringValue(excludedDomainItem); + writer.WriteNullValue(); } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); + break; + case "definition": + var allowedVersionsForDefinition = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in unitPrefix.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); + writer.WriteStartArray("definition"u8); - foreach(var hyperLinkItem in unitPrefix.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListDefinition) { - writer.WriteStringValue(hyperLinkItem); + foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(unitPrefix.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(unitPrefix.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(unitPrefix.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(unitPrefix.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(unitPrefix.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(unitPrefix.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(unitPrefix.ThingPreference); + writer.WriteEndArray(); break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing UnitPrefix for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(unitPrefix.Actor.HasValue) + case "excludeddomain": + var allowedVersionsForExcludedDomain = new List { - writer.WriteStringValue(unitPrefix.Actor.Value); - } - else + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { - writer.WriteNullValue(); + return; } - writer.WriteStartArray("alias"u8); + writer.WriteStartArray("excludedDomain"u8); - foreach(var aliasItem in unitPrefix.Alias.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedDomain) { - writer.WriteStringValue(aliasItem); + foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(unitPrefix.ClassKind.ToString()); - writer.WritePropertyName("conversionFactor"u8); - writer.WriteStringValue(unitPrefix.ConversionFactor); - writer.WriteStartArray("definition"u8); + writer.WriteEndArray(); + break; + case "excludedperson": + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var definitionItem in unitPrefix.Definition.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { - writer.WriteStringValue(definitionItem); + return; } - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); + writer.WriteStartArray("excludedPerson"u8); - foreach(var excludedDomainItem in unitPrefix.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListExcludedPerson) { - writer.WriteStringValue(excludedDomainItem); + foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } } - - writer.WriteEndArray(); - writer.WriteStartArray("excludedPerson"u8); + writer.WriteEndArray(); + break; + case "hyperlink": + var allowedVersionsForHyperLink = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - foreach(var excludedPersonItem in unitPrefix.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { - writer.WriteStringValue(excludedPersonItem); + return; } - writer.WriteEndArray(); - writer.WriteStartArray("hyperLink"u8); - foreach(var hyperLinkItem in unitPrefix.HyperLink.OrderBy(x => x, this.GuidComparer)) + if(value is IEnumerable objectListHyperLink) { - writer.WriteStringValue(hyperLinkItem); + foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } } - - writer.WriteEndArray(); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(unitPrefix.Iid); - writer.WritePropertyName("isDeprecated"u8); - writer.WriteBooleanValue(unitPrefix.IsDeprecated); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(unitPrefix.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(unitPrefix.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(unitPrefix.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(unitPrefix.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(unitPrefix.ThingPreference); + writer.WriteEndArray(); break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - - /// - /// Serialize a value for a property into a - /// - /// The name of the property to serialize - /// The object value to serialize - /// The - /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a - public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - var requestedVersion = requestedDataModelVersion.ToString(3); + case "iid": + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - switch(propertyName.ToLower()) - { - case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } - writer.WritePropertyName("actor"u8); + writer.WritePropertyName("iid"u8); if(value != null) { @@ -365,35 +291,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + case "isdeprecated": + var allowedVersionsForIsDeprecated = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("alias"u8); - - if(value is IEnumerable objectListAlias) - { - foreach(var aliasItem in objectListAlias.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - } - - writer.WriteEndArray(); - break; - case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + if(!allowedVersionsForIsDeprecated.Contains(requestedVersion)) { return; } - writer.WritePropertyName("classKind"u8); + writer.WritePropertyName("isDeprecated"u8); if(value != null) { - writer.WriteStringValue(((ClassKind)value).ToString()); + writer.WriteBooleanValue((bool)value); } else { @@ -401,17 +317,24 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "conversionfactor": - if(!AllowedVersionsPerProperty["conversionFactor"].Contains(requestedVersion)) + case "modifiedon": + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } - writer.WritePropertyName("conversionFactor"u8); + writer.WritePropertyName("modifiedOn"u8); if(value != null) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); } else { @@ -419,89 +342,51 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + case "name": + var allowedVersionsForName = new List { - return; - } - - writer.WriteStartArray("definition"u8); + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - if(value is IEnumerable objectListDefinition) - { - foreach(var definitionItem in objectListDefinition.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - } - - writer.WriteEndArray(); - break; - case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } - writer.WriteStartArray("excludedDomain"u8); - - if(value is IEnumerable objectListExcludedDomain) - { - foreach(var excludedDomainItem in objectListExcludedDomain.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - } + writer.WritePropertyName("name"u8); - writer.WriteEndArray(); - break; - case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + if(value != null) { - return; + writer.WriteStringValue((string)value); } - - writer.WriteStartArray("excludedPerson"u8); - - if(value is IEnumerable objectListExcludedPerson) + else { - foreach(var excludedPersonItem in objectListExcludedPerson.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } + writer.WriteNullValue(); } - - writer.WriteEndArray(); + break; - case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + case "revisionnumber": + var allowedVersionsForRevisionNumber = new List { - return; - } + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; - writer.WriteStartArray("hyperLink"u8); - - if(value is IEnumerable objectListHyperLink) - { - foreach(var hyperLinkItem in objectListHyperLink.OfType().OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - } - - writer.WriteEndArray(); - break; - case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } - writer.WritePropertyName("iid"u8); + writer.WritePropertyName("revisionNumber"u8); if(value != null) { - writer.WriteStringValue((Guid)value); + writer.WriteNumberValue((int)value); } else { @@ -509,17 +394,25 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "isdeprecated": - if(!AllowedVersionsPerProperty["isDeprecated"].Contains(requestedVersion)) + case "shortname": + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } - writer.WritePropertyName("isDeprecated"u8); + writer.WritePropertyName("shortName"u8); if(value != null) { - writer.WriteBooleanValue((bool)value); + writer.WriteStringValue((string)value); } else { @@ -527,17 +420,23 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + case "thingpreference": + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } - writer.WritePropertyName("modifiedOn"u8); + writer.WritePropertyName("thingPreference"u8); if(value != null) { - writer.WriteStringValue(((DateTime)value).ToString(SerializerHelper.DateTimeFormat)); + writer.WriteStringValue((string)value); } else { @@ -545,104 +444,275 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } break; - case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + default: + throw new ArgumentException($"The requested property {propertyName} does not exist on the UnitPrefix"); + } + } + + /// + /// Serializes a into an + /// + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) + { + if (thing is not UnitPrefix unitPrefix) + { + throw new ArgumentException("The thing shall be a UnitPrefix", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of UnitPrefix since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing UnitPrefix for Version 1.0.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in unitPrefix.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("name"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(unitPrefix.ClassKind.ToString()); + writer.WritePropertyName("conversionFactor"u8); + writer.WriteStringValue(unitPrefix.ConversionFactor); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in unitPrefix.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in unitPrefix.HyperLink.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(unitPrefix.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(unitPrefix.IsDeprecated); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(unitPrefix.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(unitPrefix.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(unitPrefix.ShortName); break; - case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing UnitPrefix for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in unitPrefix.Alias.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(aliasItem); } - writer.WritePropertyName("revisionNumber"u8); - - if(value != null) + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(unitPrefix.ClassKind.ToString()); + writer.WritePropertyName("conversionFactor"u8); + writer.WriteStringValue(unitPrefix.ConversionFactor); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in unitPrefix.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNumberValue((int)value); + writer.WriteStringValue(definitionItem); } - else + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in unitPrefix.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(excludedDomainItem); } - break; - case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in unitPrefix.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedPersonItem); } + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in unitPrefix.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(unitPrefix.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(unitPrefix.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(unitPrefix.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(unitPrefix.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(unitPrefix.RevisionNumber); writer.WritePropertyName("shortName"u8); - - if(value != null) + writer.WriteStringValue(unitPrefix.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing UnitPrefix for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in unitPrefix.Alias.OrderBy(x => x, this.GuidComparer)) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(aliasItem); } - else + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(unitPrefix.ClassKind.ToString()); + writer.WritePropertyName("conversionFactor"u8); + writer.WriteStringValue(unitPrefix.ConversionFactor); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in unitPrefix.Definition.OrderBy(x => x, this.GuidComparer)) { - writer.WriteNullValue(); + writer.WriteStringValue(definitionItem); } - break; - case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in unitPrefix.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) { - return; + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in unitPrefix.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in unitPrefix.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); } + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(unitPrefix.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(unitPrefix.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(unitPrefix.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(unitPrefix.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(unitPrefix.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(unitPrefix.ShortName); writer.WritePropertyName("thingPreference"u8); - - if(value != null) + writer.WriteStringValue(unitPrefix.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing UnitPrefix for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(unitPrefix.Actor.HasValue) { - writer.WriteStringValue((string)value); + writer.WriteStringValue(unitPrefix.Actor.Value); } else { writer.WriteNullValue(); } + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in unitPrefix.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(unitPrefix.ClassKind.ToString()); + writer.WritePropertyName("conversionFactor"u8); + writer.WriteStringValue(unitPrefix.ConversionFactor); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in unitPrefix.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in unitPrefix.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in unitPrefix.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in unitPrefix.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(unitPrefix.Iid); + writer.WritePropertyName("isDeprecated"u8); + writer.WriteBooleanValue(unitPrefix.IsDeprecated); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(unitPrefix.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(unitPrefix.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(unitPrefix.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(unitPrefix.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(unitPrefix.ThingPreference); break; default: - throw new ArgumentException($"The requested property {propertyName} does not exist on the UnitPrefix"); + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); } - } - /// - /// Gets the association between a name of a property and all versions where that property is defined - /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() - { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "conversionFactor", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isDeprecated", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/UserPreferenceSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/UserPreferenceSerializer.cs index 017bf854..2e84713a 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/UserPreferenceSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/UserPreferenceSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,165 +49,6 @@ namespace CDP4JsonSerializer /// public class UserPreferenceSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not UserPreference userPreference) - { - throw new ArgumentException("The thing shall be a UserPreference", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of UserPreference since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing UserPreference for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(userPreference.ClassKind.ToString()); - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(userPreference.Iid); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(userPreference.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(userPreference.ShortName); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(userPreference.Value); - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing UserPreference for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(userPreference.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in userPreference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in userPreference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(userPreference.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(userPreference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(userPreference.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(userPreference.ShortName); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(userPreference.Value); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing UserPreference for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(userPreference.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in userPreference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in userPreference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(userPreference.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(userPreference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(userPreference.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(userPreference.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(userPreference.ThingPreference); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(userPreference.Value); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing UserPreference for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(userPreference.Actor.HasValue) - { - writer.WriteStringValue(userPreference.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(userPreference.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in userPreference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in userPreference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(userPreference.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(userPreference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(userPreference.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(userPreference.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(userPreference.ThingPreference); - writer.WritePropertyName("value"u8); - writer.WriteStringValue(userPreference.Value); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -216,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -224,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -242,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -260,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -278,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -296,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -314,7 +188,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -332,7 +213,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -350,7 +239,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -368,7 +265,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -386,7 +289,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "value": - if(!AllowedVersionsPerProperty["value"].Contains(requestedVersion)) + var allowedVersionsForValue = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForValue.Contains(requestedVersion)) { return; } @@ -409,21 +320,157 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "value", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not UserPreference userPreference) + { + throw new ArgumentException("The thing shall be a UserPreference", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of UserPreference since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing UserPreference for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(userPreference.ClassKind.ToString()); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(userPreference.Iid); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(userPreference.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(userPreference.ShortName); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(userPreference.Value); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing UserPreference for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(userPreference.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in userPreference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in userPreference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(userPreference.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(userPreference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(userPreference.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(userPreference.ShortName); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(userPreference.Value); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing UserPreference for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(userPreference.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in userPreference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in userPreference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(userPreference.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(userPreference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(userPreference.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(userPreference.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(userPreference.ThingPreference); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(userPreference.Value); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing UserPreference for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(userPreference.Actor.HasValue) + { + writer.WriteStringValue(userPreference.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(userPreference.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in userPreference.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in userPreference.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(userPreference.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(userPreference.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(userPreference.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(userPreference.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(userPreference.ThingPreference); + writer.WritePropertyName("value"u8); + writer.WriteStringValue(userPreference.Value); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/UserRuleVerificationSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/UserRuleVerificationSerializer.cs index e7d7b52e..2341cbf1 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/UserRuleVerificationSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/UserRuleVerificationSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,253 +49,6 @@ namespace CDP4JsonSerializer /// public class UserRuleVerificationSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not UserRuleVerification userRuleVerification) - { - throw new ArgumentException("The thing shall be a UserRuleVerification", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.0.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of UserRuleVerification since Version is below 1.0.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.0.0": - Logger.Log(LogLevel.Trace, "Serializing UserRuleVerification for Version 1.0.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(userRuleVerification.ClassKind.ToString()); - writer.WritePropertyName("executedOn"u8); - - if(userRuleVerification.ExecutedOn.HasValue) - { - writer.WriteStringValue(userRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(userRuleVerification.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(userRuleVerification.IsActive); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(userRuleVerification.RevisionNumber); - writer.WritePropertyName("rule"u8); - writer.WriteStringValue(userRuleVerification.Rule); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(userRuleVerification.Status.ToString()); - writer.WriteStartArray("violation"u8); - - foreach(var violationItem in userRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(violationItem); - } - - writer.WriteEndArray(); - - break; - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing UserRuleVerification for Version 1.1.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(userRuleVerification.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in userRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in userRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("executedOn"u8); - - if(userRuleVerification.ExecutedOn.HasValue) - { - writer.WriteStringValue(userRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(userRuleVerification.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(userRuleVerification.IsActive); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(userRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(userRuleVerification.RevisionNumber); - writer.WritePropertyName("rule"u8); - writer.WriteStringValue(userRuleVerification.Rule); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(userRuleVerification.Status.ToString()); - writer.WriteStartArray("violation"u8); - - foreach(var violationItem in userRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(violationItem); - } - - writer.WriteEndArray(); - - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing UserRuleVerification for Version 1.2.0"); - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(userRuleVerification.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in userRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in userRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("executedOn"u8); - - if(userRuleVerification.ExecutedOn.HasValue) - { - writer.WriteStringValue(userRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(userRuleVerification.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(userRuleVerification.IsActive); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(userRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(userRuleVerification.RevisionNumber); - writer.WritePropertyName("rule"u8); - writer.WriteStringValue(userRuleVerification.Rule); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(userRuleVerification.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(userRuleVerification.ThingPreference); - writer.WriteStartArray("violation"u8); - - foreach(var violationItem in userRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(violationItem); - } - - writer.WriteEndArray(); - - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing UserRuleVerification for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(userRuleVerification.Actor.HasValue) - { - writer.WriteStringValue(userRuleVerification.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(userRuleVerification.ClassKind.ToString()); - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in userRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in userRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("executedOn"u8); - - if(userRuleVerification.ExecutedOn.HasValue) - { - writer.WriteStringValue(userRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); - } - else - { - writer.WriteNullValue(); - } - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(userRuleVerification.Iid); - writer.WritePropertyName("isActive"u8); - writer.WriteBooleanValue(userRuleVerification.IsActive); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(userRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(userRuleVerification.RevisionNumber); - writer.WritePropertyName("rule"u8); - writer.WriteStringValue(userRuleVerification.Rule); - writer.WritePropertyName("status"u8); - writer.WriteStringValue(userRuleVerification.Status.ToString()); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(userRuleVerification.ThingPreference); - writer.WriteStartArray("violation"u8); - - foreach(var violationItem in userRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(violationItem); - } - - writer.WriteEndArray(); - - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -304,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -312,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -330,7 +86,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -348,7 +112,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -366,7 +137,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -384,7 +162,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "executedon": - if(!AllowedVersionsPerProperty["executedOn"].Contains(requestedVersion)) + var allowedVersionsForExecutedOn = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExecutedOn.Contains(requestedVersion)) { return; } @@ -402,7 +188,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -420,7 +214,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "isactive": - if(!AllowedVersionsPerProperty["isActive"].Contains(requestedVersion)) + var allowedVersionsForIsActive = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIsActive.Contains(requestedVersion)) { return; } @@ -438,7 +240,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -456,7 +265,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -474,7 +291,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "rule": - if(!AllowedVersionsPerProperty["rule"].Contains(requestedVersion)) + var allowedVersionsForRule = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRule.Contains(requestedVersion)) { return; } @@ -492,7 +317,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "status": - if(!AllowedVersionsPerProperty["status"].Contains(requestedVersion)) + var allowedVersionsForStatus = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForStatus.Contains(requestedVersion)) { return; } @@ -510,7 +343,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -528,7 +367,15 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "violation": - if(!AllowedVersionsPerProperty["violation"].Contains(requestedVersion)) + var allowedVersionsForViolation = new List + { + "1.0.0", + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForViolation.Contains(requestedVersion)) { return; } @@ -551,24 +398,241 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "classKind", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "executedOn", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "isActive", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "rule", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "status", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - { "violation", new []{ "1.0.0", "1.1.0", "1.2.0", "1.3.0" }}, - }; + if (thing is not UserRuleVerification userRuleVerification) + { + throw new ArgumentException("The thing shall be a UserRuleVerification", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.0.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of UserRuleVerification since Version is below 1.0.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.0.0": + Logger.Log(LogLevel.Debug, "Serializing UserRuleVerification for Version 1.0.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(userRuleVerification.ClassKind.ToString()); + writer.WritePropertyName("executedOn"u8); + + if(userRuleVerification.ExecutedOn.HasValue) + { + writer.WriteStringValue(userRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(userRuleVerification.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(userRuleVerification.IsActive); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(userRuleVerification.RevisionNumber); + writer.WritePropertyName("rule"u8); + writer.WriteStringValue(userRuleVerification.Rule); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(userRuleVerification.Status.ToString()); + writer.WriteStartArray("violation"u8); + + foreach(var violationItem in userRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(violationItem); + } + + writer.WriteEndArray(); + break; + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing UserRuleVerification for Version 1.1.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(userRuleVerification.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in userRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in userRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("executedOn"u8); + + if(userRuleVerification.ExecutedOn.HasValue) + { + writer.WriteStringValue(userRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(userRuleVerification.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(userRuleVerification.IsActive); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(userRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(userRuleVerification.RevisionNumber); + writer.WritePropertyName("rule"u8); + writer.WriteStringValue(userRuleVerification.Rule); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(userRuleVerification.Status.ToString()); + writer.WriteStartArray("violation"u8); + + foreach(var violationItem in userRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(violationItem); + } + + writer.WriteEndArray(); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing UserRuleVerification for Version 1.2.0"); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(userRuleVerification.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in userRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in userRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("executedOn"u8); + + if(userRuleVerification.ExecutedOn.HasValue) + { + writer.WriteStringValue(userRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(userRuleVerification.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(userRuleVerification.IsActive); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(userRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(userRuleVerification.RevisionNumber); + writer.WritePropertyName("rule"u8); + writer.WriteStringValue(userRuleVerification.Rule); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(userRuleVerification.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(userRuleVerification.ThingPreference); + writer.WriteStartArray("violation"u8); + + foreach(var violationItem in userRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(violationItem); + } + + writer.WriteEndArray(); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing UserRuleVerification for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(userRuleVerification.Actor.HasValue) + { + writer.WriteStringValue(userRuleVerification.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(userRuleVerification.ClassKind.ToString()); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in userRuleVerification.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in userRuleVerification.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("executedOn"u8); + + if(userRuleVerification.ExecutedOn.HasValue) + { + writer.WriteStringValue(userRuleVerification.ExecutedOn.Value.ToString(SerializerHelper.DateTimeFormat)); + } + else + { + writer.WriteNullValue(); + } + + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(userRuleVerification.Iid); + writer.WritePropertyName("isActive"u8); + writer.WriteBooleanValue(userRuleVerification.IsActive); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(userRuleVerification.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(userRuleVerification.RevisionNumber); + writer.WritePropertyName("rule"u8); + writer.WriteStringValue(userRuleVerification.Rule); + writer.WritePropertyName("status"u8); + writer.WriteStringValue(userRuleVerification.Status.ToString()); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(userRuleVerification.ThingPreference); + writer.WriteStartArray("violation"u8); + + foreach(var violationItem in userRuleVerification.Violation.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(violationItem); + } + + writer.WriteEndArray(); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenDtoSerializer/ValueGroupSerializer.cs b/CDP4JsonSerializer/AutoGenDtoSerializer/ValueGroupSerializer.cs index 9841c231..81d529ef 100644 --- a/CDP4JsonSerializer/AutoGenDtoSerializer/ValueGroupSerializer.cs +++ b/CDP4JsonSerializer/AutoGenDtoSerializer/ValueGroupSerializer.cs @@ -33,7 +33,6 @@ namespace CDP4JsonSerializer using System.Linq; using System.Text.Json; - using CDP4Common; using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; using CDP4Common.ReportingData; @@ -50,260 +49,6 @@ namespace CDP4JsonSerializer /// public class ValueGroupSerializer : BaseThingSerializer, IThingSerializer { - /// - /// Serializes a into an - /// - /// The that have to be serialized - /// The - /// The that has been requested for the serialization - /// If the provided is not an - /// If the provided is not supported - public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) - { - if (thing is not ValueGroup valueGroup) - { - throw new ArgumentException("The thing shall be a ValueGroup", nameof(thing)); - } - - if (requestedDataModelVersion < Version.Parse("1.1.0")) - { - Logger.Log(LogLevel.Info, "Skipping serialization of ValueGroup since Version is below 1.1.0"); - return; - } - - writer.WriteStartObject(); - - switch(requestedDataModelVersion.ToString(3)) - { - case "1.1.0": - Logger.Log(LogLevel.Trace, "Serializing ValueGroup for Version 1.1.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in valueGroup.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in valueGroup.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(valueGroup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in valueGroup.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in valueGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in valueGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in valueGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(valueGroup.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(valueGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(valueGroup.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(valueGroup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(valueGroup.ShortName); - break; - case "1.2.0": - Logger.Log(LogLevel.Trace, "Serializing ValueGroup for Version 1.2.0"); - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in valueGroup.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in valueGroup.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(valueGroup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in valueGroup.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in valueGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in valueGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in valueGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(valueGroup.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(valueGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(valueGroup.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(valueGroup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(valueGroup.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(valueGroup.ThingPreference); - break; - case "1.3.0": - Logger.Log(LogLevel.Trace, "Serializing ValueGroup for Version 1.3.0"); - writer.WritePropertyName("actor"u8); - - if(valueGroup.Actor.HasValue) - { - writer.WriteStringValue(valueGroup.Actor.Value); - } - else - { - writer.WriteNullValue(); - } - - writer.WriteStartArray("alias"u8); - - foreach(var aliasItem in valueGroup.Alias.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(aliasItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("category"u8); - - foreach(var categoryItem in valueGroup.Category.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(categoryItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("classKind"u8); - writer.WriteStringValue(valueGroup.ClassKind.ToString()); - writer.WriteStartArray("definition"u8); - - foreach(var definitionItem in valueGroup.Definition.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(definitionItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedDomain"u8); - - foreach(var excludedDomainItem in valueGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedDomainItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("excludedPerson"u8); - - foreach(var excludedPersonItem in valueGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(excludedPersonItem); - } - - writer.WriteEndArray(); - - writer.WriteStartArray("hyperLink"u8); - - foreach(var hyperLinkItem in valueGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) - { - writer.WriteStringValue(hyperLinkItem); - } - - writer.WriteEndArray(); - - writer.WritePropertyName("iid"u8); - writer.WriteStringValue(valueGroup.Iid); - writer.WritePropertyName("modifiedOn"u8); - writer.WriteStringValue(valueGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); - writer.WritePropertyName("name"u8); - writer.WriteStringValue(valueGroup.Name); - writer.WritePropertyName("revisionNumber"u8); - writer.WriteNumberValue(valueGroup.RevisionNumber); - writer.WritePropertyName("shortName"u8); - writer.WriteStringValue(valueGroup.ShortName); - writer.WritePropertyName("thingPreference"u8); - writer.WriteStringValue(valueGroup.ThingPreference); - break; - default: - throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); - } - - writer.WriteEndObject(); - } - /// /// Serialize a value for a property into a /// @@ -311,7 +56,6 @@ public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataM /// The object value to serialize /// The /// The that has been requested for the serialization - /// This method should only be used in the scope of serializing a public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion) { var requestedVersion = requestedDataModelVersion.ToString(3); @@ -319,7 +63,12 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter switch(propertyName.ToLower()) { case "actor": - if(!AllowedVersionsPerProperty["actor"].Contains(requestedVersion)) + var allowedVersionsForActor = new List + { + "1.3.0", + }; + + if(!allowedVersionsForActor.Contains(requestedVersion)) { return; } @@ -337,7 +86,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "alias": - if(!AllowedVersionsPerProperty["alias"].Contains(requestedVersion)) + var allowedVersionsForAlias = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForAlias.Contains(requestedVersion)) { return; } @@ -355,7 +111,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "category": - if(!AllowedVersionsPerProperty["category"].Contains(requestedVersion)) + var allowedVersionsForCategory = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForCategory.Contains(requestedVersion)) { return; } @@ -373,7 +136,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "classkind": - if(!AllowedVersionsPerProperty["classKind"].Contains(requestedVersion)) + var allowedVersionsForClassKind = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForClassKind.Contains(requestedVersion)) { return; } @@ -391,7 +161,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "definition": - if(!AllowedVersionsPerProperty["definition"].Contains(requestedVersion)) + var allowedVersionsForDefinition = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForDefinition.Contains(requestedVersion)) { return; } @@ -409,7 +186,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludeddomain": - if(!AllowedVersionsPerProperty["excludedDomain"].Contains(requestedVersion)) + var allowedVersionsForExcludedDomain = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedDomain.Contains(requestedVersion)) { return; } @@ -427,7 +211,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "excludedperson": - if(!AllowedVersionsPerProperty["excludedPerson"].Contains(requestedVersion)) + var allowedVersionsForExcludedPerson = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForExcludedPerson.Contains(requestedVersion)) { return; } @@ -445,7 +236,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "hyperlink": - if(!AllowedVersionsPerProperty["hyperLink"].Contains(requestedVersion)) + var allowedVersionsForHyperLink = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForHyperLink.Contains(requestedVersion)) { return; } @@ -463,7 +261,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer.WriteEndArray(); break; case "iid": - if(!AllowedVersionsPerProperty["iid"].Contains(requestedVersion)) + var allowedVersionsForIid = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForIid.Contains(requestedVersion)) { return; } @@ -481,7 +286,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "modifiedon": - if(!AllowedVersionsPerProperty["modifiedOn"].Contains(requestedVersion)) + var allowedVersionsForModifiedOn = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForModifiedOn.Contains(requestedVersion)) { return; } @@ -499,7 +311,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "name": - if(!AllowedVersionsPerProperty["name"].Contains(requestedVersion)) + var allowedVersionsForName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForName.Contains(requestedVersion)) { return; } @@ -517,7 +336,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "revisionnumber": - if(!AllowedVersionsPerProperty["revisionNumber"].Contains(requestedVersion)) + var allowedVersionsForRevisionNumber = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForRevisionNumber.Contains(requestedVersion)) { return; } @@ -535,7 +361,14 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "shortname": - if(!AllowedVersionsPerProperty["shortName"].Contains(requestedVersion)) + var allowedVersionsForShortName = new List + { + "1.1.0", + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForShortName.Contains(requestedVersion)) { return; } @@ -553,7 +386,13 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter break; case "thingpreference": - if(!AllowedVersionsPerProperty["thingPreference"].Contains(requestedVersion)) + var allowedVersionsForThingPreference = new List + { + "1.2.0", + "1.3.0", + }; + + if(!allowedVersionsForThingPreference.Contains(requestedVersion)) { return; } @@ -576,25 +415,240 @@ public void SerializeProperty(string propertyName, object value, Utf8JsonWriter } /// - /// Gets the association between a name of a property and all versions where that property is defined + /// Serializes a into an /// - private static readonly IReadOnlyDictionary> AllowedVersionsPerProperty = new Dictionary>() + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + /// If the provided is not an + /// If the provided is not supported + public void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion) { - { "actor", new []{ "1.3.0" }}, - { "alias", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "category", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "classKind", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "definition", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedDomain", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "excludedPerson", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "hyperLink", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "iid", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "modifiedOn", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "name", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "revisionNumber", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "shortName", new []{ "1.1.0", "1.2.0", "1.3.0" }}, - { "thingPreference", new []{ "1.2.0", "1.3.0" }}, - }; + if (thing is not ValueGroup valueGroup) + { + throw new ArgumentException("The thing shall be a ValueGroup", nameof(thing)); + } + + if (requestedDataModelVersion < Version.Parse("1.1.0")) + { + Logger.Log(LogLevel.Info, "Skipping serialization of ValueGroup since Version is below 1.1.0"); + return; + } + + writer.WriteStartObject(); + + switch(requestedDataModelVersion.ToString(3)) + { + case "1.1.0": + Logger.Log(LogLevel.Debug, "Serializing ValueGroup for Version 1.1.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in valueGroup.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in valueGroup.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(valueGroup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in valueGroup.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in valueGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in valueGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in valueGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(valueGroup.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(valueGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(valueGroup.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(valueGroup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(valueGroup.ShortName); + break; + case "1.2.0": + Logger.Log(LogLevel.Debug, "Serializing ValueGroup for Version 1.2.0"); + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in valueGroup.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in valueGroup.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(valueGroup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in valueGroup.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in valueGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in valueGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in valueGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(valueGroup.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(valueGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(valueGroup.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(valueGroup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(valueGroup.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(valueGroup.ThingPreference); + break; + case "1.3.0": + Logger.Log(LogLevel.Debug, "Serializing ValueGroup for Version 1.3.0"); + writer.WritePropertyName("actor"u8); + + if(valueGroup.Actor.HasValue) + { + writer.WriteStringValue(valueGroup.Actor.Value); + } + else + { + writer.WriteNullValue(); + } + + writer.WriteStartArray("alias"u8); + + foreach(var aliasItem in valueGroup.Alias.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(aliasItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("category"u8); + + foreach(var categoryItem in valueGroup.Category.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(categoryItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("classKind"u8); + writer.WriteStringValue(valueGroup.ClassKind.ToString()); + writer.WriteStartArray("definition"u8); + + foreach(var definitionItem in valueGroup.Definition.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(definitionItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedDomain"u8); + + foreach(var excludedDomainItem in valueGroup.ExcludedDomain.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedDomainItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("excludedPerson"u8); + + foreach(var excludedPersonItem in valueGroup.ExcludedPerson.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(excludedPersonItem); + } + + writer.WriteEndArray(); + writer.WriteStartArray("hyperLink"u8); + + foreach(var hyperLinkItem in valueGroup.HyperLink.OrderBy(x => x, this.GuidComparer)) + { + writer.WriteStringValue(hyperLinkItem); + } + + writer.WriteEndArray(); + writer.WritePropertyName("iid"u8); + writer.WriteStringValue(valueGroup.Iid); + writer.WritePropertyName("modifiedOn"u8); + writer.WriteStringValue(valueGroup.ModifiedOn.ToString(SerializerHelper.DateTimeFormat)); + writer.WritePropertyName("name"u8); + writer.WriteStringValue(valueGroup.Name); + writer.WritePropertyName("revisionNumber"u8); + writer.WriteNumberValue(valueGroup.RevisionNumber); + writer.WritePropertyName("shortName"u8); + writer.WriteStringValue(valueGroup.ShortName); + writer.WritePropertyName("thingPreference"u8); + writer.WriteStringValue(valueGroup.ThingPreference); + break; + default: + throw new NotSupportedException($"The provided version {requestedDataModelVersion.ToString(3)} is not supported"); + } + + writer.WriteEndObject(); + } } } diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/ActualFiniteStateKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/ActualFiniteStateKindDeserializer.cs new file mode 100644 index 00000000..f1d450c5 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/ActualFiniteStateKindDeserializer.cs @@ -0,0 +1,64 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.EngineeringModelData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class ActualFiniteStateKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static ActualFiniteStateKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "MANDATORY" => ActualFiniteStateKind.MANDATORY, + "FORBIDDEN" => ActualFiniteStateKind.FORBIDDEN, + _ => throw new InvalidDataException($"{value} is not a valid for ActualFiniteStateKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationApprovalKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationApprovalKindDeserializer.cs new file mode 100644 index 00000000..4102f47f --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationApprovalKindDeserializer.cs @@ -0,0 +1,65 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.ReportingData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class AnnotationApprovalKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static AnnotationApprovalKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "ACCEPTED" => AnnotationApprovalKind.ACCEPTED, + "REJECTED" => AnnotationApprovalKind.REJECTED, + "WITHDRAWN" => AnnotationApprovalKind.WITHDRAWN, + _ => throw new InvalidDataException($"{value} is not a valid for AnnotationApprovalKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationClassificationKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationClassificationKindDeserializer.cs new file mode 100644 index 00000000..d9ae34f9 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationClassificationKindDeserializer.cs @@ -0,0 +1,64 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.ReportingData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class AnnotationClassificationKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static AnnotationClassificationKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "MAJOR" => AnnotationClassificationKind.MAJOR, + "MINOR" => AnnotationClassificationKind.MINOR, + _ => throw new InvalidDataException($"{value} is not a valid for AnnotationClassificationKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationStatusKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationStatusKindDeserializer.cs new file mode 100644 index 00000000..2448faab --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/AnnotationStatusKindDeserializer.cs @@ -0,0 +1,68 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.ReportingData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class AnnotationStatusKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static AnnotationStatusKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "OPEN" => AnnotationStatusKind.OPEN, + "DONE" => AnnotationStatusKind.DONE, + "CLOSED" => AnnotationStatusKind.CLOSED, + "INVALID" => AnnotationStatusKind.INVALID, + "WONTFIX" => AnnotationStatusKind.WONTFIX, + "NOT_APPLICABLE" => AnnotationStatusKind.NOT_APPLICABLE, + _ => throw new InvalidDataException($"{value} is not a valid for AnnotationStatusKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/BooleanOperatorKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/BooleanOperatorKindDeserializer.cs new file mode 100644 index 00000000..850f139b --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/BooleanOperatorKindDeserializer.cs @@ -0,0 +1,65 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.EngineeringModelData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class BooleanOperatorKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static BooleanOperatorKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "AND" => BooleanOperatorKind.AND, + "OR" => BooleanOperatorKind.OR, + "XOR" => BooleanOperatorKind.XOR, + _ => throw new InvalidDataException($"{value} is not a valid for BooleanOperatorKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/ClassKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/ClassKindDeserializer.cs new file mode 100644 index 00000000..cca7ec8a --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/ClassKindDeserializer.cs @@ -0,0 +1,243 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.CommonData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class ClassKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static ClassKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "ActionItem" => ClassKind.ActionItem, + "ActualFiniteState" => ClassKind.ActualFiniteState, + "ActualFiniteStateList" => ClassKind.ActualFiniteStateList, + "Alias" => ClassKind.Alias, + "AndExpression" => ClassKind.AndExpression, + "Approval" => ClassKind.Approval, + "ArrayParameterType" => ClassKind.ArrayParameterType, + "BinaryNote" => ClassKind.BinaryNote, + "BinaryRelationship" => ClassKind.BinaryRelationship, + "BinaryRelationshipRule" => ClassKind.BinaryRelationshipRule, + "Book" => ClassKind.Book, + "BooleanExpression" => ClassKind.BooleanExpression, + "BooleanParameterType" => ClassKind.BooleanParameterType, + "Bounds" => ClassKind.Bounds, + "BuiltInRuleVerification" => ClassKind.BuiltInRuleVerification, + "Category" => ClassKind.Category, + "ChangeProposal" => ClassKind.ChangeProposal, + "ChangeRequest" => ClassKind.ChangeRequest, + "Citation" => ClassKind.Citation, + "Color" => ClassKind.Color, + "CommonFileStore" => ClassKind.CommonFileStore, + "CompoundParameterType" => ClassKind.CompoundParameterType, + "Constant" => ClassKind.Constant, + "ContractChangeNotice" => ClassKind.ContractChangeNotice, + "ContractDeviation" => ClassKind.ContractDeviation, + "ConversionBasedUnit" => ClassKind.ConversionBasedUnit, + "CyclicRatioScale" => ClassKind.CyclicRatioScale, + "DateParameterType" => ClassKind.DateParameterType, + "DateTimeParameterType" => ClassKind.DateTimeParameterType, + "DecompositionRule" => ClassKind.DecompositionRule, + "DefinedThing" => ClassKind.DefinedThing, + "Definition" => ClassKind.Definition, + "DependentParameterTypeAssignment" => ClassKind.DependentParameterTypeAssignment, + "DerivedQuantityKind" => ClassKind.DerivedQuantityKind, + "DerivedUnit" => ClassKind.DerivedUnit, + "DiagramCanvas" => ClassKind.DiagramCanvas, + "DiagramEdge" => ClassKind.DiagramEdge, + "DiagramElementContainer" => ClassKind.DiagramElementContainer, + "DiagramElementThing" => ClassKind.DiagramElementThing, + "DiagrammingStyle" => ClassKind.DiagrammingStyle, + "DiagramObject" => ClassKind.DiagramObject, + "DiagramShape" => ClassKind.DiagramShape, + "DiagramThingBase" => ClassKind.DiagramThingBase, + "DiscussionItem" => ClassKind.DiscussionItem, + "DomainFileStore" => ClassKind.DomainFileStore, + "DomainOfExpertise" => ClassKind.DomainOfExpertise, + "DomainOfExpertiseGroup" => ClassKind.DomainOfExpertiseGroup, + "ElementBase" => ClassKind.ElementBase, + "ElementDefinition" => ClassKind.ElementDefinition, + "ElementUsage" => ClassKind.ElementUsage, + "EmailAddress" => ClassKind.EmailAddress, + "EngineeringModel" => ClassKind.EngineeringModel, + "EngineeringModelDataAnnotation" => ClassKind.EngineeringModelDataAnnotation, + "EngineeringModelDataDiscussionItem" => ClassKind.EngineeringModelDataDiscussionItem, + "EngineeringModelDataNote" => ClassKind.EngineeringModelDataNote, + "EngineeringModelSetup" => ClassKind.EngineeringModelSetup, + "EnumerationParameterType" => ClassKind.EnumerationParameterType, + "EnumerationValueDefinition" => ClassKind.EnumerationValueDefinition, + "ExclusiveOrExpression" => ClassKind.ExclusiveOrExpression, + "ExternalIdentifierMap" => ClassKind.ExternalIdentifierMap, + "File" => ClassKind.File, + "FileRevision" => ClassKind.FileRevision, + "FileStore" => ClassKind.FileStore, + "FileType" => ClassKind.FileType, + "Folder" => ClassKind.Folder, + "GenericAnnotation" => ClassKind.GenericAnnotation, + "Glossary" => ClassKind.Glossary, + "Goal" => ClassKind.Goal, + "HyperLink" => ClassKind.HyperLink, + "IdCorrespondence" => ClassKind.IdCorrespondence, + "IndependentParameterTypeAssignment" => ClassKind.IndependentParameterTypeAssignment, + "IntervalScale" => ClassKind.IntervalScale, + "Iteration" => ClassKind.Iteration, + "IterationSetup" => ClassKind.IterationSetup, + "LinearConversionUnit" => ClassKind.LinearConversionUnit, + "LogarithmicScale" => ClassKind.LogarithmicScale, + "LogEntryChangelogItem" => ClassKind.LogEntryChangelogItem, + "MappingToReferenceScale" => ClassKind.MappingToReferenceScale, + "MeasurementScale" => ClassKind.MeasurementScale, + "MeasurementUnit" => ClassKind.MeasurementUnit, + "ModellingAnnotationItem" => ClassKind.ModellingAnnotationItem, + "ModellingThingReference" => ClassKind.ModellingThingReference, + "ModelLogEntry" => ClassKind.ModelLogEntry, + "ModelReferenceDataLibrary" => ClassKind.ModelReferenceDataLibrary, + "MultiRelationship" => ClassKind.MultiRelationship, + "MultiRelationshipRule" => ClassKind.MultiRelationshipRule, + "NaturalLanguage" => ClassKind.NaturalLanguage, + "NestedElement" => ClassKind.NestedElement, + "NestedParameter" => ClassKind.NestedParameter, + "Note" => ClassKind.Note, + "NotExpression" => ClassKind.NotExpression, + "NotThing" => ClassKind.NotThing, + "Option" => ClassKind.Option, + "OrdinalScale" => ClassKind.OrdinalScale, + "OrExpression" => ClassKind.OrExpression, + "Organization" => ClassKind.Organization, + "OrganizationalParticipant" => ClassKind.OrganizationalParticipant, + "OwnedStyle" => ClassKind.OwnedStyle, + "Page" => ClassKind.Page, + "Parameter" => ClassKind.Parameter, + "ParameterBase" => ClassKind.ParameterBase, + "ParameterGroup" => ClassKind.ParameterGroup, + "ParameterizedCategoryRule" => ClassKind.ParameterizedCategoryRule, + "ParameterOrOverrideBase" => ClassKind.ParameterOrOverrideBase, + "ParameterOverride" => ClassKind.ParameterOverride, + "ParameterOverrideValueSet" => ClassKind.ParameterOverrideValueSet, + "ParameterSubscription" => ClassKind.ParameterSubscription, + "ParameterSubscriptionValueSet" => ClassKind.ParameterSubscriptionValueSet, + "ParameterType" => ClassKind.ParameterType, + "ParameterTypeComponent" => ClassKind.ParameterTypeComponent, + "ParameterValue" => ClassKind.ParameterValue, + "ParameterValueSet" => ClassKind.ParameterValueSet, + "ParameterValueSetBase" => ClassKind.ParameterValueSetBase, + "ParametricConstraint" => ClassKind.ParametricConstraint, + "Participant" => ClassKind.Participant, + "ParticipantPermission" => ClassKind.ParticipantPermission, + "ParticipantRole" => ClassKind.ParticipantRole, + "Person" => ClassKind.Person, + "PersonPermission" => ClassKind.PersonPermission, + "PersonRole" => ClassKind.PersonRole, + "Point" => ClassKind.Point, + "PossibleFiniteState" => ClassKind.PossibleFiniteState, + "PossibleFiniteStateList" => ClassKind.PossibleFiniteStateList, + "PrefixedUnit" => ClassKind.PrefixedUnit, + "Publication" => ClassKind.Publication, + "QuantityKind" => ClassKind.QuantityKind, + "QuantityKindFactor" => ClassKind.QuantityKindFactor, + "RatioScale" => ClassKind.RatioScale, + "ReferenceDataLibrary" => ClassKind.ReferenceDataLibrary, + "ReferencerRule" => ClassKind.ReferencerRule, + "ReferenceSource" => ClassKind.ReferenceSource, + "RelationalExpression" => ClassKind.RelationalExpression, + "Relationship" => ClassKind.Relationship, + "RelationshipParameterValue" => ClassKind.RelationshipParameterValue, + "RequestForDeviation" => ClassKind.RequestForDeviation, + "RequestForWaiver" => ClassKind.RequestForWaiver, + "Requirement" => ClassKind.Requirement, + "RequirementsContainer" => ClassKind.RequirementsContainer, + "RequirementsContainerParameterValue" => ClassKind.RequirementsContainerParameterValue, + "RequirementsGroup" => ClassKind.RequirementsGroup, + "RequirementsSpecification" => ClassKind.RequirementsSpecification, + "ReviewItemDiscrepancy" => ClassKind.ReviewItemDiscrepancy, + "Rule" => ClassKind.Rule, + "RuleVerification" => ClassKind.RuleVerification, + "RuleVerificationList" => ClassKind.RuleVerificationList, + "RuleViolation" => ClassKind.RuleViolation, + "SampledFunctionParameterType" => ClassKind.SampledFunctionParameterType, + "ScalarParameterType" => ClassKind.ScalarParameterType, + "ScaleReferenceQuantityValue" => ClassKind.ScaleReferenceQuantityValue, + "ScaleValueDefinition" => ClassKind.ScaleValueDefinition, + "Section" => ClassKind.Section, + "SharedStyle" => ClassKind.SharedStyle, + "SimpleParameterizableThing" => ClassKind.SimpleParameterizableThing, + "SimpleParameterValue" => ClassKind.SimpleParameterValue, + "SimpleQuantityKind" => ClassKind.SimpleQuantityKind, + "SimpleUnit" => ClassKind.SimpleUnit, + "SiteDirectory" => ClassKind.SiteDirectory, + "SiteDirectoryDataAnnotation" => ClassKind.SiteDirectoryDataAnnotation, + "SiteDirectoryDataDiscussionItem" => ClassKind.SiteDirectoryDataDiscussionItem, + "SiteDirectoryThingReference" => ClassKind.SiteDirectoryThingReference, + "SiteLogEntry" => ClassKind.SiteLogEntry, + "SiteReferenceDataLibrary" => ClassKind.SiteReferenceDataLibrary, + "Solution" => ClassKind.Solution, + "SpecializedQuantityKind" => ClassKind.SpecializedQuantityKind, + "Stakeholder" => ClassKind.Stakeholder, + "StakeholderValue" => ClassKind.StakeholderValue, + "StakeHolderValueMap" => ClassKind.StakeHolderValueMap, + "StakeHolderValueMapSettings" => ClassKind.StakeHolderValueMapSettings, + "TelephoneNumber" => ClassKind.TelephoneNumber, + "Term" => ClassKind.Term, + "TextParameterType" => ClassKind.TextParameterType, + "TextualNote" => ClassKind.TextualNote, + "Thing" => ClassKind.Thing, + "ThingReference" => ClassKind.ThingReference, + "TimeOfDayParameterType" => ClassKind.TimeOfDayParameterType, + "TopContainer" => ClassKind.TopContainer, + "UnitFactor" => ClassKind.UnitFactor, + "UnitPrefix" => ClassKind.UnitPrefix, + "UserPreference" => ClassKind.UserPreference, + "UserRuleVerification" => ClassKind.UserRuleVerification, + "ValueGroup" => ClassKind.ValueGroup, + _ => throw new InvalidDataException($"{value} is not a valid for ClassKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/EngineeringModelKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/EngineeringModelKindDeserializer.cs new file mode 100644 index 00000000..d0990d71 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/EngineeringModelKindDeserializer.cs @@ -0,0 +1,66 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.SiteDirectoryData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class EngineeringModelKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static EngineeringModelKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "STUDY_MODEL" => EngineeringModelKind.STUDY_MODEL, + "TEMPLATE_MODEL" => EngineeringModelKind.TEMPLATE_MODEL, + "MODEL_CATALOGUE" => EngineeringModelKind.MODEL_CATALOGUE, + "SCRATCH_MODEL" => EngineeringModelKind.SCRATCH_MODEL, + _ => throw new InvalidDataException($"{value} is not a valid for EngineeringModelKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/InterfaceEndKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/InterfaceEndKindDeserializer.cs new file mode 100644 index 00000000..f8d5372d --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/InterfaceEndKindDeserializer.cs @@ -0,0 +1,67 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.EngineeringModelData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class InterfaceEndKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static InterfaceEndKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "NONE" => InterfaceEndKind.NONE, + "UNDIRECTED" => InterfaceEndKind.UNDIRECTED, + "INPUT" => InterfaceEndKind.INPUT, + "OUTPUT" => InterfaceEndKind.OUTPUT, + "IN_OUT" => InterfaceEndKind.IN_OUT, + _ => throw new InvalidDataException($"{value} is not a valid for InterfaceEndKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/LogEntryChangelogItemKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/LogEntryChangelogItemKindDeserializer.cs new file mode 100644 index 00000000..a5be3bc3 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/LogEntryChangelogItemKindDeserializer.cs @@ -0,0 +1,65 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.CommonData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class LogEntryChangelogItemKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static LogEntryChangelogItemKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "ADD" => LogEntryChangelogItemKind.ADD, + "UPDATE" => LogEntryChangelogItemKind.UPDATE, + "DELETE" => LogEntryChangelogItemKind.DELETE, + _ => throw new InvalidDataException($"{value} is not a valid for LogEntryChangelogItemKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/LogLevelKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/LogLevelKindDeserializer.cs new file mode 100644 index 00000000..96f9c0db --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/LogLevelKindDeserializer.cs @@ -0,0 +1,66 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.CommonData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class LogLevelKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static LogLevelKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "TRACE" => LogLevelKind.TRACE, + "DEBUG" => LogLevelKind.DEBUG, + "INFO" => LogLevelKind.INFO, + "USER" => LogLevelKind.USER, + _ => throw new InvalidDataException($"{value} is not a valid for LogLevelKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/LogarithmBaseKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/LogarithmBaseKindDeserializer.cs new file mode 100644 index 00000000..5f132393 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/LogarithmBaseKindDeserializer.cs @@ -0,0 +1,65 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.SiteDirectoryData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class LogarithmBaseKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static LogarithmBaseKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "NATURAL" => LogarithmBaseKind.NATURAL, + "BASE2" => LogarithmBaseKind.BASE2, + "BASE10" => LogarithmBaseKind.BASE10, + _ => throw new InvalidDataException($"{value} is not a valid for LogarithmBaseKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/NumberSetKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/NumberSetKindDeserializer.cs new file mode 100644 index 00000000..c2305d32 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/NumberSetKindDeserializer.cs @@ -0,0 +1,66 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.SiteDirectoryData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class NumberSetKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static NumberSetKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "NATURAL_NUMBER_SET" => NumberSetKind.NATURAL_NUMBER_SET, + "INTEGER_NUMBER_SET" => NumberSetKind.INTEGER_NUMBER_SET, + "RATIONAL_NUMBER_SET" => NumberSetKind.RATIONAL_NUMBER_SET, + "REAL_NUMBER_SET" => NumberSetKind.REAL_NUMBER_SET, + _ => throw new InvalidDataException($"{value} is not a valid for NumberSetKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/ParameterSwitchKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/ParameterSwitchKindDeserializer.cs new file mode 100644 index 00000000..1dc6fcd3 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/ParameterSwitchKindDeserializer.cs @@ -0,0 +1,65 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.EngineeringModelData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class ParameterSwitchKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static ParameterSwitchKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "COMPUTED" => ParameterSwitchKind.COMPUTED, + "MANUAL" => ParameterSwitchKind.MANUAL, + "REFERENCE" => ParameterSwitchKind.REFERENCE, + _ => throw new InvalidDataException($"{value} is not a valid for ParameterSwitchKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/ParticipantAccessRightKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/ParticipantAccessRightKindDeserializer.cs new file mode 100644 index 00000000..45115065 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/ParticipantAccessRightKindDeserializer.cs @@ -0,0 +1,69 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.CommonData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class ParticipantAccessRightKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static ParticipantAccessRightKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "NOT_APPLICABLE" => ParticipantAccessRightKind.NOT_APPLICABLE, + "NONE" => ParticipantAccessRightKind.NONE, + "SAME_AS_CONTAINER" => ParticipantAccessRightKind.SAME_AS_CONTAINER, + "SAME_AS_SUPERCLASS" => ParticipantAccessRightKind.SAME_AS_SUPERCLASS, + "READ" => ParticipantAccessRightKind.READ, + "MODIFY" => ParticipantAccessRightKind.MODIFY, + "MODIFY_IF_OWNER" => ParticipantAccessRightKind.MODIFY_IF_OWNER, + _ => throw new InvalidDataException($"{value} is not a valid for ParticipantAccessRightKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/PersonAccessRightKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/PersonAccessRightKindDeserializer.cs new file mode 100644 index 00000000..331bbf18 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/PersonAccessRightKindDeserializer.cs @@ -0,0 +1,71 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.CommonData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class PersonAccessRightKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static PersonAccessRightKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "NOT_APPLICABLE" => PersonAccessRightKind.NOT_APPLICABLE, + "NONE" => PersonAccessRightKind.NONE, + "SAME_AS_CONTAINER" => PersonAccessRightKind.SAME_AS_CONTAINER, + "SAME_AS_SUPERCLASS" => PersonAccessRightKind.SAME_AS_SUPERCLASS, + "READ" => PersonAccessRightKind.READ, + "MODIFY" => PersonAccessRightKind.MODIFY, + "READ_IF_PARTICIPANT" => PersonAccessRightKind.READ_IF_PARTICIPANT, + "MODIFY_IF_PARTICIPANT" => PersonAccessRightKind.MODIFY_IF_PARTICIPANT, + "MODIFY_OWN_PERSON" => PersonAccessRightKind.MODIFY_OWN_PERSON, + _ => throw new InvalidDataException($"{value} is not a valid for PersonAccessRightKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/RelationalOperatorKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/RelationalOperatorKindDeserializer.cs new file mode 100644 index 00000000..5cdf396b --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/RelationalOperatorKindDeserializer.cs @@ -0,0 +1,68 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.EngineeringModelData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class RelationalOperatorKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static RelationalOperatorKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "EQ" => RelationalOperatorKind.EQ, + "NE" => RelationalOperatorKind.NE, + "LT" => RelationalOperatorKind.LT, + "GT" => RelationalOperatorKind.GT, + "LE" => RelationalOperatorKind.LE, + "GE" => RelationalOperatorKind.GE, + _ => throw new InvalidDataException($"{value} is not a valid for RelationalOperatorKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/RuleVerificationStatusKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/RuleVerificationStatusKindDeserializer.cs new file mode 100644 index 00000000..9f73e8c3 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/RuleVerificationStatusKindDeserializer.cs @@ -0,0 +1,66 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.EngineeringModelData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class RuleVerificationStatusKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static RuleVerificationStatusKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "NONE" => RuleVerificationStatusKind.NONE, + "PASSED" => RuleVerificationStatusKind.PASSED, + "FAILED" => RuleVerificationStatusKind.FAILED, + "INCONCLUSIVE" => RuleVerificationStatusKind.INCONCLUSIVE, + _ => throw new InvalidDataException($"{value} is not a valid for RuleVerificationStatusKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/StudyPhaseKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/StudyPhaseKindDeserializer.cs new file mode 100644 index 00000000..0bbad8cc --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/StudyPhaseKindDeserializer.cs @@ -0,0 +1,66 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.SiteDirectoryData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class StudyPhaseKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static StudyPhaseKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "PREPARATION_PHASE" => StudyPhaseKind.PREPARATION_PHASE, + "DESIGN_SESSION_PHASE" => StudyPhaseKind.DESIGN_SESSION_PHASE, + "REPORTING_PHASE" => StudyPhaseKind.REPORTING_PHASE, + "COMPLETED_STUDY" => StudyPhaseKind.COMPLETED_STUDY, + _ => throw new InvalidDataException($"{value} is not a valid for StudyPhaseKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/VcardEmailAddressKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/VcardEmailAddressKindDeserializer.cs new file mode 100644 index 00000000..4fb8c099 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/VcardEmailAddressKindDeserializer.cs @@ -0,0 +1,64 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.SiteDirectoryData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class VcardEmailAddressKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static VcardEmailAddressKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "WORK" => VcardEmailAddressKind.WORK, + "HOME" => VcardEmailAddressKind.HOME, + _ => throw new InvalidDataException($"{value} is not a valid for VcardEmailAddressKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/AutoGenEnumDeserializers/VcardTelephoneNumberKindDeserializer.cs b/CDP4JsonSerializer/AutoGenEnumDeserializers/VcardTelephoneNumberKindDeserializer.cs new file mode 100644 index 00000000..9048d9c7 --- /dev/null +++ b/CDP4JsonSerializer/AutoGenEnumDeserializers/VcardTelephoneNumberKindDeserializer.cs @@ -0,0 +1,71 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ + +namespace CDP4JsonSerializer +{ + using System; + using System.IO; + using System.Text.Json; + + using CDP4Common.SiteDirectoryData; + + /// + /// The purpose of the is to deserialize a JSON object to a + /// + internal static class VcardTelephoneNumberKindDeserializer + { + /// + /// Deserializes the into a + /// + /// the element to deserialize + /// the + /// if the can't be parsed into the + internal static VcardTelephoneNumberKind Deserialize(JsonElement jsonElement) + { + var value = jsonElement.GetString(); + + return value switch + { + "WORK" => VcardTelephoneNumberKind.WORK, + "HOME" => VcardTelephoneNumberKind.HOME, + "VOICE" => VcardTelephoneNumberKind.VOICE, + "TEXT" => VcardTelephoneNumberKind.TEXT, + "FAX" => VcardTelephoneNumberKind.FAX, + "CELL" => VcardTelephoneNumberKind.CELL, + "PAGER" => VcardTelephoneNumberKind.PAGER, + "TEXTPHONE" => VcardTelephoneNumberKind.TEXTPHONE, + "VIDEO" => VcardTelephoneNumberKind.VIDEO, + _ => throw new InvalidDataException($"{value} is not a valid for VcardTelephoneNumberKind") + }; + } + } +} + +// ------------------------------------------------------------------------------------------------ +// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!-------- +// ------------------------------------------------------------------------------------------------ diff --git a/CDP4JsonSerializer/CDP4JsonSerializer.csproj b/CDP4JsonSerializer/CDP4JsonSerializer.csproj index b6b4e93a..642b0c28 100644 --- a/CDP4JsonSerializer/CDP4JsonSerializer.csproj +++ b/CDP4JsonSerializer/CDP4JsonSerializer.csproj @@ -6,27 +6,28 @@ CDP4JsonSerializer Community Edition 27.4.2 CDP4 JSON Serialization Library - Copyright © Starion Group S.A. - Sam, Merlin, Alex, Naron, Alexander, Yevhen, Nathanael + Copyright © RHEA System S.A. + Sam, Merlin, Alex, Naron, Alexander, Yevhen, Nathanael, Jaime, Antoine CDP4JsonSerializer-CE true - https://github.com/STARIONGROUP/COMET-SDK-Community-Edition - true + https://github.com/RHEAGROUP/COMET-SDK-Community-Edition + true cdp4-icon.png true true - snupkg - https://github.com/STARIONGROUP/COMET-SDK-Community-Edition.git + https://github.com/RHEAGROUP/COMET-SDK-Community-Edition.git CDP COMET ECSS-E-TM-10-25 JSON LGPL-3.0-only [Update] to CDP4Common 27.4.2 - README.md + 11.0 + + @@ -36,21 +37,10 @@ - - - - - - - - - - - \ No newline at end of file diff --git a/CDP4JsonSerializer/Cdp4JsonSerializer.cs b/CDP4JsonSerializer/Cdp4JsonSerializer.cs index 0275cd39..2d72690b 100644 --- a/CDP4JsonSerializer/Cdp4JsonSerializer.cs +++ b/CDP4JsonSerializer/Cdp4JsonSerializer.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2021 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer { @@ -28,17 +28,15 @@ namespace CDP4JsonSerializer using System.Collections.Generic; using System.Diagnostics; using System.IO; + using System.Text.Json; + using System.Text.Json.Serialization; using CDP4Common.MetaInfo; using CDP4JsonSerializer.JsonConverter; - using Newtonsoft.Json; - using Newtonsoft.Json.Converters; - using Newtonsoft.Json.Serialization; - using NLog; - + using Thing = CDP4Common.DTO.Thing; /// @@ -52,7 +50,7 @@ public class Cdp4JsonSerializer : ICdp4JsonSerializer private static readonly Logger Logger = LogManager.GetCurrentClassLogger(); /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// /// The meta Info Provider. @@ -66,12 +64,17 @@ public Cdp4JsonSerializer(IMetaDataProvider metaInfoProvider, Version supportedV } /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// public Cdp4JsonSerializer() { } + /// + /// Gets or sets the options for the serializer + /// + public JsonSerializerOptions JsonSerializerOptions { get; private set; } + /// /// Gets or sets the data model version for this request. /// @@ -83,14 +86,19 @@ public Cdp4JsonSerializer() public IMetaDataProvider MetaInfoProvider { get; private set; } /// - /// Initialize this instance with the required and supported + /// Initialize this instance with the required and supported /// - /// The - /// The supported - public void Initialize(IMetaDataProvider metaInfoProvider, Version supportedVersion) + /// The + /// The supported + public virtual void Initialize(IMetaDataProvider metaInfoProvider, Version supportedVersion) { this.MetaInfoProvider = metaInfoProvider; this.RequestDataModelVersion = supportedVersion; + + this.JsonSerializerOptions = SerializerOptions.Copy(); + this.JsonSerializerOptions.Converters.Add(new ThingSerializer(this.MetaInfoProvider, this.RequestDataModelVersion)); + this.JsonSerializerOptions.Converters.Add(new ClasslessDtoSerializer(this.MetaInfoProvider, this.RequestDataModelVersion)); + this.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter(null, false)); } /// @@ -115,31 +123,25 @@ public void SerializeToStream(object collectionSource, Stream outputStream) } var sw = Stopwatch.StartNew(); - - var serializer = this.CreateJsonSerializer(); - Logger.Trace("initializing JsonTextWriter"); - var jsonWriter = new JsonTextWriter(new StreamWriter(outputStream)); - - Logger.Trace("Serialize to JsonTextWriter"); - serializer.Serialize(jsonWriter, collectionSource); - jsonWriter.Flush(); + Logger.Trace("initializing Serialization"); + JsonSerializer.Serialize(outputStream, collectionSource, this.JsonSerializerOptions); sw.Stop(); Logger.Debug("SerializeToStream finished in {0} [ms]", sw.ElapsedMilliseconds); } /// - /// Serialize the to a JSON stream + /// Serialize the to a JSON stream /// /// - /// The + /// The /// /// /// The output stream to which the serialized JSON objects are written /// /// - /// A value indicating whether the contained shall be included in the JSON stream + /// A value indicating whether the contained shall be included in the JSON stream /// /// A JSON stream public void SerializeToStream(CDP4Common.CommonData.Thing source, Stream outputStream, bool isExtentDeep) @@ -160,9 +162,11 @@ public void SerializeToStream(CDP4Common.CommonData.Thing source, Stream outputS } var dtos = new List(); + if (isExtentDeep) { var pocos = source.QueryContainedThingsDeep(); + foreach (var poco in pocos) { dtos.Add(poco.ToDto()); @@ -179,10 +183,10 @@ public void SerializeToStream(CDP4Common.CommonData.Thing source, Stream outputS } /// - /// Serialize the to a JSON string + /// Serialize the to a JSON string /// - /// The - /// A value indicating whether the contained shall be processed + /// The + /// A value indicating whether the contained shall be processed /// The JSON string public string SerializeToString(CDP4Common.CommonData.Thing source, bool isExtentDeep) { @@ -190,27 +194,24 @@ public string SerializeToString(CDP4Common.CommonData.Thing source, bool isExten { throw new InvalidOperationException("The supported version or the metainfo provider has not been set. Call the Initialize method to set them."); } - - string jsonString; + Logger.Trace("initializing MemoryStream"); - using (var stream = new MemoryStream()) - { - this.SerializeToStream(source, stream, isExtentDeep); + using var stream = new MemoryStream(); - Logger.Trace("rewind MemoryStream"); - stream.Position = 0; + this.SerializeToStream(source, stream, isExtentDeep); - Logger.Trace("initializing StreamReader"); - using (var reader = new StreamReader(stream)) - { - var sw = new Stopwatch(); - sw.Start(); - jsonString = reader.ReadToEnd(); - sw.Stop(); - Logger.Trace("write json stream to json string in {0} [ms]", sw.ElapsedMilliseconds); - } - } + Logger.Trace("rewind MemoryStream"); + stream.Position = 0; + + Logger.Trace("initializing StreamReader"); + using var reader = new StreamReader(stream); + + var sw = new Stopwatch(); + sw.Start(); + var jsonString = reader.ReadToEnd(); + sw.Stop(); + Logger.Trace("write json stream to json string in {0} [ms]", sw.ElapsedMilliseconds); return jsonString; } @@ -222,7 +223,7 @@ public string SerializeToString(CDP4Common.CommonData.Thing source, bool isExten /// The content Stream. /// /// - /// The the deserialized collection of . + /// The the deserialized collection of . /// public IEnumerable Deserialize(Stream contentStream) { @@ -248,43 +249,48 @@ public T Deserialize(Stream contentStream) throw new InvalidOperationException("The supported version or the metainfo provider has not been set. Call the Initialize method to set them."); } - var serializer = this.CreateJsonSerializer(); - - T data; - using (var streamReader = new StreamReader(contentStream)) - using (var jsonTextReader = new JsonTextReader(streamReader)) - { - var sw = new Stopwatch(); - sw.Start(); - data = serializer.Deserialize(jsonTextReader); - Logger.Trace("Deserialize from stream in {0} [ms]", sw.ElapsedMilliseconds); - } - + var sw = new Stopwatch(); + sw.Start(); + var data = JsonSerializer.Deserialize(contentStream, this.JsonSerializerOptions); + Logger.Trace("Deserialize from stream in {0} [ms]", sw.ElapsedMilliseconds); return data; } /// - /// Create a + /// Serialize an object into a string /// - /// - /// an instance of - /// - protected JsonSerializer CreateJsonSerializer() + /// The object to serialize + /// The serialized string + /// + /// If the or + /// has not been initialized + /// + public string SerializeToString(object toSerialize) { - Logger.Trace("initializing JsonSerializer"); - var serializer = new JsonSerializer + if (this.RequestDataModelVersion == null || this.MetaInfoProvider == null) { - ContractResolver = new CamelCasePropertyNamesContractResolver(), - NullValueHandling = NullValueHandling.Ignore - }; - - Logger.Trace("register converters"); - serializer.Converters.Add(new ThingSerializer(this.MetaInfoProvider, this.RequestDataModelVersion)); - serializer.Converters.Add(new ClasslessDtoSerializer(this.MetaInfoProvider, this.RequestDataModelVersion)); - serializer.Converters.Add(new ClassKindConverter()); - serializer.Converters.Add(new StringEnumConverter()); - - return serializer; + throw new InvalidOperationException("The supported version or the metainfo provider has not been set. Call the Initialize method to set them."); + } + + Logger.Trace("initializing MemoryStream"); + + using var stream = new MemoryStream(); + + this.SerializeToStream(toSerialize, stream); + + Logger.Trace("rewind MemoryStream"); + stream.Position = 0; + + Logger.Trace("initializing StreamReader"); + using var reader = new StreamReader(stream); + + var sw = new Stopwatch(); + sw.Start(); + var jsonString = reader.ReadToEnd(); + sw.Stop(); + Logger.Trace("write json stream to json string in {0} [ms]", sw.ElapsedMilliseconds); + + return jsonString; } } -} \ No newline at end of file +} diff --git a/CDP4JsonSerializer/DtoSerializer/BaseThingSerializer.cs b/CDP4JsonSerializer/DtoSerializer/BaseThingSerializer.cs index 647c21cf..a10662dd 100644 --- a/CDP4JsonSerializer/DtoSerializer/BaseThingSerializer.cs +++ b/CDP4JsonSerializer/DtoSerializer/BaseThingSerializer.cs @@ -1,46 +1,54 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer { using System; + using CDP4Common.Comparers; using CDP4Common.Types; + using NLog; + /// /// Abstract supertype from which all derive /// public abstract class BaseThingSerializer { + /// + /// The NLog logger + /// + protected static readonly Logger Logger = LogManager.GetCurrentClassLogger(); + /// /// The used to compare 2 s /// - protected readonly GuidComparer guidComparer = new GuidComparer(); + protected readonly GuidComparer GuidComparer = new(); /// /// The used to compare 2 s /// - protected readonly OrderedItemComparer orderedItemComparer = new OrderedItemComparer(); + protected readonly OrderedItemComparer OrderedItemComparer = new(); } -} \ No newline at end of file +} diff --git a/CDP4JsonSerializer/DtoSerializer/IThingSerializer.cs b/CDP4JsonSerializer/DtoSerializer/IThingSerializer.cs index 6209d85d..cd501b18 100644 --- a/CDP4JsonSerializer/DtoSerializer/IThingSerializer.cs +++ b/CDP4JsonSerializer/DtoSerializer/IThingSerializer.cs @@ -1,51 +1,56 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer { using System; - using System.Collections.Generic; + using System.Text.Json; + using System.Text.Json.Nodes; using CDP4Common.DTO; - using Newtonsoft.Json.Linq; - /// - /// Definition of the used to serialize instances of to a + /// Definition of the used to serialize instances of to a + /// /// public interface IThingSerializer { /// - /// Gets the map containing the serialization method for each property + /// Serialize a value for a property into a /// - IReadOnlyDictionary> PropertySerializerMap { get; } + /// The name of the property to serialize + /// The object value to serialize + /// The + /// The that has been requested for the serialization + void SerializeProperty(string propertyName, object value, Utf8JsonWriter writer, Version requestedDataModelVersion); /// - /// Serialize the + /// Serializes a into an /// - /// The to serialize - /// The - JObject Serialize(Thing thing); + /// The that have to be serialized + /// The + /// The that has been requested for the serialization + void Serialize(Thing thing, Utf8JsonWriter writer, Version requestedDataModelVersion); } -} \ No newline at end of file +} diff --git a/CDP4JsonSerializer/Helper/SerializerHelper.cs b/CDP4JsonSerializer/Helper/SerializerHelper.cs index b1f28d08..c1f22cfc 100644 --- a/CDP4JsonSerializer/Helper/SerializerHelper.cs +++ b/CDP4JsonSerializer/Helper/SerializerHelper.cs @@ -1,53 +1,56 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2021 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer { using System; using System.Collections.Generic; using System.Linq; + using System.Text.Json; using System.Text.RegularExpressions; using CDP4Common.Types; - using Newtonsoft.Json; - using Newtonsoft.Json.Linq; - /// /// Utility method to convert a JSON token to a CDP4 type /// public static class SerializerHelper { + /// + /// Gets the format of the to use + /// + public const string DateTimeFormat = "yyyy-MM-ddTHH:mm:ss.fffZ"; + /// /// Regex used for conversion of Json value to string /// - private static readonly Regex JsonToValueArrayRegex = new Regex(@"^\[(.*)\]$", RegexOptions.Singleline); - + private static readonly Regex JsonToValueArrayRegex = new(@"^\[(.*)\]$", RegexOptions.Singleline); + /// /// Regex used for conversion of HStore value to string /// - private static readonly Regex HstoreToValueArrayRegex = new Regex(@"^\{(.*)\}$", RegexOptions.Singleline); + private static readonly Regex HstoreToValueArrayRegex = new(@"^\{(.*)\}$", RegexOptions.Singleline); /// /// Convert a string to a @@ -78,44 +81,82 @@ public static string ToJsonString(this ValueArray valueArray) } /// - /// Serialize a to a + /// Writes an into an /// - /// The - /// The - public static JObject ToJsonObject(this OrderedItem orderedItem) + /// The + /// The to write + public static void WriteOrderedItem(this Utf8JsonWriter writer, OrderedItem orderedItem) { - var jsonObject = new JObject(); - jsonObject.Add("k", new JValue(orderedItem.K)); + writer.WriteStartObject(); + writer.WriteNumber("k"u8, orderedItem.K); if (orderedItem.M != null) { - jsonObject.Add("m", new JValue(orderedItem.M)); + writer.WriteNumber("m"u8, orderedItem.M.Value); + } + + writer.WritePropertyName("v"u8); + + switch (orderedItem.V) + { + case string stringValue: + writer.WriteStringValue(stringValue); + break; + case Guid guidValue: + writer.WriteStringValue(guidValue); + break; + case bool boolValue: + writer.WriteBooleanValue(boolValue); + break; + case int intValue: + writer.WriteNumberValue(intValue); + break; + case double doubleValue: + writer.WriteNumberValue(doubleValue); + break; + case float floatValue: + writer.WriteNumberValue(floatValue); + break; + default: + throw new NotSupportedException($"The type {orderedItem.V.GetType().Name} is not supported for the {nameof(OrderedItem)} serialization"); } - jsonObject.Add("v", new JValue(orderedItem.V)); - return jsonObject; + writer.WriteEndObject(); } /// - /// Instantiate a from a + /// Instantiate a from a /// - /// The + /// The /// The - public static IEnumerable ToOrderedItemCollection(this JToken jsonToken) + public static IEnumerable ToOrderedItemCollection(this JsonElement jsonToken) { var list = new List(); - foreach (var token in jsonToken) + + foreach (var prop in jsonToken.EnumerateArray()) { + var keyProp = prop.GetProperty("k"); + var valueKind = keyProp.ValueKind; + var key = long.MinValue; + + if (valueKind == JsonValueKind.String) + { + key = Convert.ToInt64(keyProp.GetString()); + } + else if (valueKind == JsonValueKind.Number) + { + key = keyProp.GetInt64(); + } + var orderedItem = new OrderedItem { - K = token["k"].ToObject(), - V = token["v"].ToString() + K = key, + V = prop.GetProperty("v").GetString(), }; - var move = token["m"]; - if (move != null) + if (prop.TryGetProperty("m", out var value) && value.ValueKind != JsonValueKind.Null) { - orderedItem.M = move.ToObject(); + orderedItem.M = value.GetInt64(); } list.Add(orderedItem); @@ -124,19 +165,6 @@ public static IEnumerable ToOrderedItemCollection(this JToken jsonT return list; } - /// - /// Assert Whether a is null or empty - /// - /// The - /// True if the is null or empty - public static bool IsNullOrEmpty(this JToken token) - { - return (token == null) || - (token.Type == JTokenType.Array && !token.HasValues) || - (token.Type == JTokenType.Object && !token.HasValues) || - (token.Type == JTokenType.Null); - } - /// /// Convert a string to a /// @@ -159,7 +187,7 @@ private static ValueArray ToValueArray(string valueArrayString, Regex rege foreach (Match match in test) { - stringValues.Add(JsonConvert.DeserializeObject($"\"{match.Groups[1].Value}\"")); + stringValues.Add(JsonSerializer.Deserialize($"\"{match.Groups[1].Value}\"")); } var convertedStringList = stringValues.Select(m => (T)Convert.ChangeType(m, typeof(T))).ToList(); @@ -189,7 +217,7 @@ private static IEnumerable ValueArrayToStringList(ValueArray val for (var i = 0; i < items.Count; i++) { - items[i] = $"{JsonConvert.SerializeObject(items[i])}"; + items[i] = $"{JsonSerializer.Serialize(items[i], SerializerOptions.Options)}"; } return items; diff --git a/CDP4JsonSerializer/ICdp4JsonSerializer.cs b/CDP4JsonSerializer/ICdp4JsonSerializer.cs index 271c9134..79d3bb65 100644 --- a/CDP4JsonSerializer/ICdp4JsonSerializer.cs +++ b/CDP4JsonSerializer/ICdp4JsonSerializer.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer { @@ -99,17 +99,14 @@ public interface ICdp4JsonSerializer IEnumerable Deserialize(Stream contentStream); /// - /// Convenience method that deserializes the passed in JSON content stream + /// Serialize an object into a string /// - /// - /// The type info for which deserialization will be performed - /// - /// - /// The content Stream. - /// - /// - /// The the deserialized instance of the specified Type - /// - T Deserialize(Stream contentStream); + /// The object to serialize + /// The serialized string + /// + /// If the or + /// has not been initialized + /// + string SerializeToString(object toSerialize); } -} \ No newline at end of file +} diff --git a/CDP4JsonSerializer/JsonConverter/ClassKindConverter.cs b/CDP4JsonSerializer/JsonConverter/ClassKindConverter.cs deleted file mode 100644 index 10b4b937..00000000 --- a/CDP4JsonSerializer/JsonConverter/ClassKindConverter.cs +++ /dev/null @@ -1,50 +0,0 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2021 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program; if not, write to the Free Software Foundation, -// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. -// -// -------------------------------------------------------------------------------------------------------------------- - -namespace CDP4JsonSerializer.JsonConverter -{ - using System; - - using CDP4Common.CommonData; - - using Newtonsoft.Json.Converters; - - /// - /// Specific converter for values. - /// - public class ClassKindConverter : StringEnumConverter - { - /// - /// Determines whether this instance can convert the specified object type. - /// - /// Type of the object. - /// - /// true if this instance can convert the specified object type; otherwise, false. - /// - public override bool CanConvert(Type objectType) - { - return objectType == typeof(ClassKind); - } - } -} diff --git a/CDP4JsonSerializer/JsonConverter/ClasslessDtoSerializer.cs b/CDP4JsonSerializer/JsonConverter/ClasslessDtoSerializer.cs index 0f7cb2c1..d036a1d4 100644 --- a/CDP4JsonSerializer/JsonConverter/ClasslessDtoSerializer.cs +++ b/CDP4JsonSerializer/JsonConverter/ClasslessDtoSerializer.cs @@ -1,30 +1,34 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer.JsonConverter { using System; + using System.Text.Json; + using System.Text.Json.Nodes; + using System.Text.Json.Serialization; + using System.Collections.Generic; using CDP4Common; @@ -33,17 +37,14 @@ namespace CDP4JsonSerializer.JsonConverter using CDP4JsonSerializer.Helper; - using Newtonsoft.Json; - using Newtonsoft.Json.Linq; - using NLog; using Dto = CDP4Common.DTO; /// - /// The for s + /// The for s /// - public class ClasslessDtoSerializer : JsonConverter + public class ClasslessDtoSerializer : JsonConverter { /// /// The NLog logger @@ -51,149 +52,96 @@ public class ClasslessDtoSerializer : JsonConverter private static readonly Logger Logger = LogManager.GetCurrentClassLogger(); /// - /// The + /// The data model version for this request. /// - private readonly IMetaDataProvider metaDataProvider; + private readonly Version dataModelVersion; /// - /// The data model version for this request. + /// The /// - private readonly Version dataModelVersion; + private readonly IMetaDataProvider metaDataProvider; /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// - /// The + /// The /// - /// The supported + /// The supported public ClasslessDtoSerializer(IMetaDataProvider metaDataProvider, Version dataModelVersion) { this.metaDataProvider = metaDataProvider; this.dataModelVersion = dataModelVersion; } - /// - /// Gets a value indicating whether this converter supports JSON read. - /// - public override bool CanRead - { - get { return true; } - } - - /// - /// Gets a value indicating whether this converter supports JSON write. - /// - public override bool CanWrite - { - get { return true; } - } - /// /// Override of the can convert type check. /// - /// + /// /// The object type. /// /// /// true if this converter is to be used. /// - public override bool CanConvert(Type objectType) + public override bool CanConvert(Type typeToConvert) { - return typeof(ClasslessDTO).QueryIsAssignableFrom(objectType); + return typeof(ClasslessDTO).QueryIsAssignableFrom(typeToConvert); } /// - /// Write JSON. + /// Tries to deserialize a JSON into a /// - /// - /// The JSON writer. - /// - /// - /// The value object. - /// - /// - /// The JSON serializer. - /// - public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) + /// the + /// the to convert + /// the options of the serializer + /// the + public override ClasslessDTO Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { - var classlessDto = (ClasslessDTO)value; - - var typeName = classlessDto["ClassKind"].ToString(); - var classVersion = new Version(this.metaDataProvider.GetClassVersion(typeName)); - if (classVersion > this.dataModelVersion) - { - // skip type serialization if the data version is larger then the request data model version - return; - } - - var jsonObject = ((ClasslessDTO)value).ToJsonObject(); - - var nonSerializablePropeties = new List(); - foreach (var kvp in jsonObject) + if (!JsonElement.TryParseValue(ref reader, out var jsonElement)) { - var propertyVersion = new Version(this.metaDataProvider.GetPropertyVersion(typeName, Helper.Utils.CapitalizeFirstLetter(kvp.Key))); - if (propertyVersion > this.dataModelVersion) - { - nonSerializablePropeties.Add(kvp.Key); - } + Logger.Error("The data object in the JSON array could not be cast to a JsonElement type."); + throw new NullReferenceException("The data object in the JSON array could not be cast to a JsonElement type."); } - foreach (var nonSerializablePropety in nonSerializablePropeties) - { - jsonObject.Remove(nonSerializablePropety); - } + var dto = jsonElement?.ToDto(); + var classlessDto = this.GenerateClasslessDto(jsonElement.Value, dto); - jsonObject.WriteTo(writer); + return classlessDto; } /// - /// Override of the Read JSON method. + /// Write a JSON /// - /// - /// The JSON reader. - /// - /// - /// The type information of the object. - /// - /// - /// The existing object value. - /// - /// - /// The JSON serializer. - /// - /// - /// A deserialized instance. - /// - public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) + /// the + /// the to serialize + /// the options of the serializer + public override void Write(Utf8JsonWriter writer, ClasslessDTO value, JsonSerializerOptions options) { - // load object from stream - var jsonObject = JObject.Load(reader); + var typeName = value["ClassKind"].ToString(); + var classVersion = new Version(this.metaDataProvider.GetClassVersion(typeName)); - if (jsonObject == null) + if (classVersion > this.dataModelVersion) { - Logger.Error("The data object in the JSON array could not be cast to a JObject type."); - throw new NullReferenceException("The data object in the JSON array could not be cast to a JObject type."); + // skip type serialization if the data version is larger then the request data model version + return; } - var dto = jsonObject.ToDto(); - var classlessDto = this.GenerateClasslessDto(jsonObject, dto); - - return classlessDto; + value.SerializeClasslessDto(writer, this.dataModelVersion); } /// - /// Create a from a and a partial + /// Create a from a and a partial /// - /// The - /// The - /// The generated - private ClasslessDTO GenerateClasslessDto(JObject jsonObject, Dto.Thing dto) + /// The + /// The + /// The generated + private ClasslessDTO GenerateClasslessDto(JsonElement jsonObject, Dto.Thing dto) { var metainfo = this.metaDataProvider.GetMetaInfo(dto.ClassKind.ToString()); var classlessDto = new ClasslessDTO(); - foreach (var property in jsonObject.Properties()) + + foreach (var property in jsonObject.EnumerateObject()) { var propertyName = Utils.CapitalizeFirstLetter(property.Name); classlessDto.Add(propertyName, metainfo.GetValue(propertyName, dto)); @@ -202,4 +150,4 @@ private ClasslessDTO GenerateClasslessDto(JObject jsonObject, Dto.Thing dto) return classlessDto; } } -} \ No newline at end of file +} diff --git a/CDP4JsonSerializer/JsonConverter/ThingConverterExtensions.cs b/CDP4JsonSerializer/JsonConverter/ThingConverterExtensions.cs new file mode 100644 index 00000000..5dfa81c4 --- /dev/null +++ b/CDP4JsonSerializer/JsonConverter/ThingConverterExtensions.cs @@ -0,0 +1,111 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +namespace CDP4JsonSerializer.JsonConverter +{ + using System; + using System.Linq; + + using CDP4Common.DTO; + using CDP4Common.MetaInfo; + + /// + /// The purpose of the is to implement extra business logic for hand-coded serialization to + /// decide to include or exclude classes from the serialization process + /// + public class ThingConverterExtensions + { + /// + /// Asserts whether an object shall be serialized or not + /// + /// + /// the for which the serialization is to be asserted + /// + /// + /// The used to provide meta data + /// + /// + /// The data model version to be used to determine whether a class shall be serialized or not + /// + /// + /// returns true when the object shall be serialzed, false if not + /// + public bool AssertSerialization(object value, IMetaDataProvider metaDataProvider, Version version) + { + if (value is PersonPermission personPermission) + { + var classVersion = new Version(metaDataProvider.GetClassVersion(personPermission.ObjectClass.ToString())); + + if (classVersion > version) + { + return false; + } + } + + if (value is ParticipantPermission participantPermission) + { + var classVersion = new Version(metaDataProvider.GetClassVersion(participantPermission.ObjectClass.ToString())); + + if (classVersion > version) + { + return false; + } + } + + return true; + } + + /// + /// Checks the 's property for compatibility + /// + /// + /// the for which the serialization is to be asserted + /// + /// + /// The used to provide meta data + /// + /// + /// The data model version to be used to determine whether a class shall be serialized or not + /// + public void CheckCategoryPermissibleClasses(object value, IMetaDataProvider metaDataProvider, Version version) + { + if (value is Category category) + { + var permissibleClasses = category.PermissibleClass.ToList(); + + foreach (var permissibleClass in permissibleClasses) + { + var permissibleClassVersion = new Version(metaDataProvider.GetClassVersion(permissibleClass.ToString())); + + if (permissibleClassVersion <= version) + { + continue; + } + + category.PermissibleClass.Remove(permissibleClass); + } + } + } + } +} diff --git a/CDP4JsonSerializer/JsonConverter/ThingSerializer.cs b/CDP4JsonSerializer/JsonConverter/ThingSerializer.cs index 2a1f7186..bc8bb911 100644 --- a/CDP4JsonSerializer/JsonConverter/ThingSerializer.cs +++ b/CDP4JsonSerializer/JsonConverter/ThingSerializer.cs @@ -1,47 +1,43 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4JsonSerializer.JsonConverter { using System; - using System.Collections.Generic; - using System.Linq; + using System.Text.Json; + using System.Text.Json.Serialization; using CDP4Common.DTO; - using CDP4Common.Extensions; using CDP4Common.MetaInfo; using CDP4Common.Polyfills; - using Newtonsoft.Json; - using Newtonsoft.Json.Linq; - using NLog; /// - /// The that is responsible for (De)serialization on a + /// The that is responsible for (De)serialization on a /// - public class ThingSerializer : JsonConverter + public class ThingSerializer : JsonConverter { /// /// The NLog logger @@ -54,10 +50,20 @@ public class ThingSerializer : JsonConverter private readonly Version dataModelVersion; /// - /// The used to determine whether a class is to be serialized or not + /// Override default null handling + /// + public override bool HandleNull => true; + + /// + /// The used to determine whether a class is to be serialized or not /// private readonly ThingConverterExtensions thingConverterExtensions; + /// + /// Gets or sets the meta info provider. + /// + private IMetaDataProvider MetaInfoProvider { get; set; } + /// /// Initializes a new instance of the class. /// @@ -75,21 +81,6 @@ public ThingSerializer(IMetaDataProvider metaInfoProvider, Version dataModelVers this.thingConverterExtensions = new ThingConverterExtensions(); } - /// - /// Gets a value indicating whether this converter supports JSON read. - /// - public override bool CanRead => true; - - /// - /// Gets a value indicating whether this converter supports JSON write. - /// - public override bool CanWrite => true; - - /// - /// Gets or sets the meta info provider. - /// - private IMetaDataProvider MetaInfoProvider { get; set; } - /// /// Override of the can convert type check. /// @@ -105,18 +96,33 @@ public override bool CanConvert(Type objectType) } /// - /// Write JSON. + /// Tries to deserialize a JSON into a /// - /// - /// The JSON writer. - /// - /// - /// The value object. - /// - /// - /// The JSON serializer. - /// - public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) + /// the + /// the to convert + /// the options of the serializer + /// the + public override Thing Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + // load object from stream + if (!JsonElement.TryParseValue(ref reader, out var jsonElement)) + { + Logger.Error("The data object in the JSON array could not be cast to a JsonElement type."); + throw new NullReferenceException("The data object in the JSON array could not be cast to a JsonElement type."); + } + + var newThing = jsonElement?.ToDto(); + + return newThing; + } + + /// + /// Write a JSON + /// + /// the + /// the to serialize + /// the options of the serializer + public override void Write(Utf8JsonWriter writer, Thing value, JsonSerializerOptions options) { var typeName = value.GetType().Name; var classVersion = new Version(this.MetaInfoProvider.GetClassVersion(typeName)); @@ -134,62 +140,7 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s } this.thingConverterExtensions.CheckCategoryPermissibleClasses(value, this.MetaInfoProvider, this.dataModelVersion); - - var jsonObject = ((Thing)value).ToJsonObject(); - - // remove versioned properties - var nonSerializableProperties = new List(); - - foreach (var kvp in jsonObject) - { - var propertyVersion = new Version(this.MetaInfoProvider.GetPropertyVersion(typeName, Helper.Utils.CapitalizeFirstLetter(kvp.Key))); - - if (propertyVersion > this.dataModelVersion) - { - nonSerializableProperties.Add(kvp.Key); - } - } - - foreach (var nonSerializableProperty in nonSerializableProperties) - { - jsonObject.Remove(nonSerializableProperty); - } - - jsonObject.WriteTo(writer); - } - - /// - /// Override of the Read JSON method. - /// - /// - /// The JSON reader. - /// - /// - /// The type information of the object. - /// - /// - /// The existing object value. - /// - /// - /// The JSON serializer. - /// - /// - /// A deserialized instance. - /// - public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) - { - // load object from stream - var jsonObject = JObject.Load(reader); - - if (jsonObject == null) - { - Logger.Error("The data object in the JSON array could not be cast to a JObject type."); - throw new NullReferenceException("The data object in the JSON array could not be cast to a JObject type."); - } - - var newThing = jsonObject.ToDto(); - - return newThing; + value.SerializeThing(writer, this.dataModelVersion); } } } diff --git a/CDP4JsonSerializer/Properties/AssemblyInfo.cs b/CDP4JsonSerializer/Properties/AssemblyInfo.cs index b51edd40..0f5b8ac5 100644 --- a/CDP4JsonSerializer/Properties/AssemblyInfo.cs +++ b/CDP4JsonSerializer/Properties/AssemblyInfo.cs @@ -24,5 +24,6 @@ using System.Runtime.CompilerServices; -[assembly: InternalsVisibleTo("CDP4JsonSerializer.Tests")] -[assembly: InternalsVisibleTo("CDP4JsonSerializer.NetCore.Tests")] \ No newline at end of file +[assembly: InternalsVisibleTo("Cdp4JsonSerializer")] +[assembly: InternalsVisibleTo("Cdp4JsonSerializer.Tests")] +[assembly: InternalsVisibleTo("Cdp4JsonSerializer.NetCore.Tests")] \ No newline at end of file diff --git a/CDP4JsonSerializer/SerializerOptions.cs b/CDP4JsonSerializer/SerializerOptions.cs new file mode 100644 index 00000000..ac115c6b --- /dev/null +++ b/CDP4JsonSerializer/SerializerOptions.cs @@ -0,0 +1,88 @@ +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +// ------------------------------------------------------------------------------------------------------------------------------- + +namespace CDP4JsonSerializer +{ + using System.Text.Json; + + /// + /// Static class with the options used in the serializer + /// + public class SerializerOptions + { + /// + /// Backing field for the property + /// + private static JsonSerializerOptions options; + + /// + /// Object to lock the options + /// + private static readonly object Lock = new(); + + /// + /// Creates a new instance of type + /// + private SerializerOptions() + { + } + + /// + /// Gets the instance that it's been used of this + /// + public static JsonSerializerOptions Options + { + get + { + if (options == null) + { + lock (Lock) + { + if (options == null) + { + options = new JsonSerializerOptions() + { + WriteIndented = false, + Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping, + PropertyNameCaseInsensitive = true, + NumberHandling = System.Text.Json.Serialization.JsonNumberHandling.AllowReadingFromString + }; + } + } + } + + return options; + } + } + + /// + /// Copies the and returns a new instance + /// + /// the new instance + public static JsonSerializerOptions Copy() + { + return new JsonSerializerOptions(Options); + } + } +} diff --git a/CDP4ServicesDal.NetCore.Tests/CDP4ServicesDal.NetCore.Tests.csproj b/CDP4ServicesDal.NetCore.Tests/CDP4ServicesDal.NetCore.Tests.csproj index 6e34b8ef..d83fed82 100644 --- a/CDP4ServicesDal.NetCore.Tests/CDP4ServicesDal.NetCore.Tests.csproj +++ b/CDP4ServicesDal.NetCore.Tests/CDP4ServicesDal.NetCore.Tests.csproj @@ -11,7 +11,8 @@ - + + diff --git a/CDP4ServicesDal.NetCore.Tests/CdpServicesDalTestFixture.cs b/CDP4ServicesDal.NetCore.Tests/CdpServicesDalTestFixture.cs index 0c988696..e5a54827 100644 --- a/CDP4ServicesDal.NetCore.Tests/CdpServicesDalTestFixture.cs +++ b/CDP4ServicesDal.NetCore.Tests/CdpServicesDalTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal.Tests { @@ -49,7 +49,8 @@ namespace CDP4ServicesDal.Tests using CDP4Dal.Exceptions; using CDP4Dal.Operations; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Operations; + using CDP4DalCommon.Protocol.Tasks; using NUnit.Framework; @@ -92,7 +93,7 @@ public void Setup() this.siteDirectory = new SiteDirectory(Guid.Parse("f13de6f8-b03a-46e7-a492-53b2f260f294"), this.session.Assembler.Cache, this.uri); var lazySiteDirectory = new Lazy(() => this.siteDirectory); lazySiteDirectory.Value.Cache.TryAdd(new CacheKey(lazySiteDirectory.Value.Iid, null), lazySiteDirectory); - + this.jsonSerializerOptions = new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, @@ -183,7 +184,7 @@ public void Verify_That_When_constructed_with_null_httpclient_throws_exception() HttpClient httpClient = null; Assert.Throws(() => new CdpServicesDal(httpClient)); } - + [Test] [Category("WebServicesDependent")] public async Task VerifThatAClosedDalCannotBeClosedAgain() @@ -254,17 +255,18 @@ public void VerifyThatDalThatIsNotOpenCannotBeClosed() Assert.Throws(() => this.dal.Close()); } - [Test] + [TestCase(true)] + [TestCase(false)] [Category("WebServicesDependent")] - public async Task VerifyThatReadReturnsCorrectDTO() + public async Task VerifyThatReadReturnsCorrectDTO(bool isMessagePackSupported) { - this.dal = new CdpServicesDal(); + this.dal = new CdpServicesDal(isMessagePackSupported); var returned = (await this.dal.Open(this.credentials, this.cancelationTokenSource.Token)).ToList(); Assert.That(returned, Is.Not.Null); Assert.That(returned, Is.Not.Empty); - var sd = returned.OfType().First(); + var sd = returned.First(x => x.ClassKind == ClassKind.SiteDirectory); var attributes = new QueryAttributes(); var readResult = await dal.Read(sd, this.cancelationTokenSource.Token, attributes); @@ -326,6 +328,7 @@ public void VerifyThatPostBodyIsCorrectlyResolves() IsSynonym = false, LanguageCode = "en", }; + testDtoOriginal.AddContainer(ClassKind.DomainOfExpertise, domainOfExpertiseIid); testDtoOriginal.AddContainer(ClassKind.SiteDirectory, siteDirecortoryIid); @@ -335,6 +338,7 @@ public void VerifyThatPostBodyIsCorrectlyResolves() IsSynonym = true, LanguageCode = "en", }; + testDtoModified.AddContainer(ClassKind.DomainOfExpertise, domainOfExpertiseIid); testDtoModified.AddContainer(ClassKind.SiteDirectory, siteDirecortoryIid); @@ -343,6 +347,7 @@ public void VerifyThatPostBodyIsCorrectlyResolves() Content = "somecontent", LanguageCode = "en", }; + testDtoOriginal2.AddContainer(ClassKind.DomainOfExpertise, domainOfExpertiseIid); testDtoOriginal2.AddContainer(ClassKind.SiteDirectory, siteDirecortoryIid); @@ -351,6 +356,7 @@ public void VerifyThatPostBodyIsCorrectlyResolves() Content = "somecontent2", LanguageCode = "en", }; + testDtoModified2.AddContainer(ClassKind.DomainOfExpertise, domainOfExpertiseIid); testDtoModified2.AddContainer(ClassKind.SiteDirectory, siteDirecortoryIid); @@ -477,10 +483,11 @@ public async Task AssemblerSynchronizePerformanceTest() await assembler.Clear(); } }, Throws.Nothing); - + var synchronizeMeanElapsedTime = elapsedTimes.Average(); var maxElapsedTime = elapsedTimes.Max(); var minElapsedTime = elapsedTimes.Min(); + // 204.64 | 181 | 458 ms // refactor: 31.61 | 26 | 283 } @@ -497,7 +504,7 @@ public async Task VerifyThatFileCanBeUploaded() var files = new List { filepath }; var contentHash = "F73747371CFD9473C19A0A7F99BCAB008474C4CA"; - var uri = new Uri("https://cdp4services-test.cdp4.org"); + var uri = new Uri("https://cdp4services-test.cdp4.org"); this.credentials = new Credentials("admin", "pass", uri); var returned = await this.dal.Open(this.credentials, this.cancelationTokenSource.Token); @@ -621,7 +628,7 @@ public async Task Verify_that_opens_returns_expected_result() public async Task Verify_that_open_with_proxy_returns_expected_result() { var proxySettings = new ProxySettings(new Uri("http://tinyproxy:8888")); - + var uri = new Uri("https://cdp4services-test.cdp4.org"); this.credentials = new Credentials("admin", "pass", uri, false, proxySettings); @@ -630,16 +637,15 @@ public async Task Verify_that_open_with_proxy_returns_expected_result() Assert.That(result, Is.Not.Null); } - + [Test] [Category("WebServicesDependent")] public async Task Verify_that_multiple_read_requests_can_be_made_in_parallel() { var uri = new Uri("https://cdp4services-test.cdp4.org"); var credentials = new Credentials("admin", "pass", uri); - + var dal = new CdpServicesDal(); - var result = await dal.Open(credentials, new CancellationToken()); @@ -699,7 +705,7 @@ public async Task VerifyReadCometTask() this.dal = new CdpServicesDal(httpClient); this.SetDalToBeOpen(this.dal); - + var cometTaskId = Guid.NewGuid(); var requestHandler = mockHttp.When($"{CdpServicesDal.CometTaskRoute}/{cometTaskId}"); @@ -748,7 +754,7 @@ public async Task VerifyReadCometTasks() this.dal = new CdpServicesDal(httpClient); this.SetDalToBeOpen(this.dal); - + var requestHandler = mockHttp.When($"{CdpServicesDal.CometTaskRoute}"); var notFoundHttpResponse = new HttpResponseMessage() @@ -764,7 +770,7 @@ public async Task VerifyReadCometTasks() var cometTasks = new List() { - new () + new() { Id = Guid.NewGuid(), Actor = Guid.NewGuid(), @@ -830,7 +836,7 @@ public async Task VerifyWriteLongRunningTask() newCometTaskResponse.Content = new StringContent(JsonSerializer.Serialize(cometTask, this.jsonSerializerOptions)); SetHttpHeader(newCometTaskResponse, "application/json"); - var longRunningTaskResult = await this.dal.Write(operationContainer,1); + var longRunningTaskResult = await this.dal.Write(operationContainer, 1); Assert.Multiple(() => { @@ -848,7 +854,7 @@ public async Task VerifyWriteLongRunningTask() thingsResponse.Content = new StreamContent(stream); SetHttpHeader(thingsResponse, "application/json"); - longRunningTaskResult = await this.dal.Write(operationContainer,1); + longRunningTaskResult = await this.dal.Write(operationContainer, 1); Assert.Multiple(() => { diff --git a/CDP4ServicesDal.NetCore.Tests/CopyOperationHandlerTestFixture.cs b/CDP4ServicesDal.NetCore.Tests/CopyOperationHandlerTestFixture.cs index dd10f7cd..4aa8d38b 100644 --- a/CDP4ServicesDal.NetCore.Tests/CopyOperationHandlerTestFixture.cs +++ b/CDP4ServicesDal.NetCore.Tests/CopyOperationHandlerTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal.Tests { @@ -36,6 +36,8 @@ namespace CDP4ServicesDal.Tests using CDP4Dal.Operations; using CDP4Dal.Permission; + using CDP4DalCommon.Protocol.Operations; + using Moq; using NUnit.Framework; diff --git a/CDP4ServicesDal.NetCore.Tests/OperationModifierTestFixture.cs b/CDP4ServicesDal.NetCore.Tests/OperationModifierTestFixture.cs index 0bbed62b..ddaa9a7d 100644 --- a/CDP4ServicesDal.NetCore.Tests/OperationModifierTestFixture.cs +++ b/CDP4ServicesDal.NetCore.Tests/OperationModifierTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal.Tests { @@ -34,6 +34,8 @@ namespace CDP4ServicesDal.Tests using CDP4Dal; using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + using Moq; using NUnit.Framework; diff --git a/CDP4ServicesDal.NetCore.Tests/PostOperationTestFixture.cs b/CDP4ServicesDal.NetCore.Tests/PostOperationTestFixture.cs index 35f2d839..ce856018 100644 --- a/CDP4ServicesDal.NetCore.Tests/PostOperationTestFixture.cs +++ b/CDP4ServicesDal.NetCore.Tests/PostOperationTestFixture.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft, Yevhen Ikonnykov -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal.Tests { @@ -35,34 +35,35 @@ namespace CDP4ServicesDal.Tests using CDP4Common.MetaInfo; using CDP4Common.Types; - using CDP4JsonSerializer; - using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + + using CDP4DalJsonSerializer; + using CDP4ServicesDal.Tests.Helper; - - using Newtonsoft.Json; - + using NUnit.Framework; - + using File = System.IO.File; - + [TestFixture] public class PostOperationTestFixture { - private Cdp4JsonSerializer serializer; + private Cdp4DalJsonSerializer serializer; [SetUp] public void Setup() { var metamodel = new MetaDataProvider(); - this.serializer = new Cdp4JsonSerializer(metamodel, new Version(1, 1, 0)); + this.serializer = new Cdp4DalJsonSerializer(metamodel, new Version(1, 1, 0)); } [Test] public void Verify_that_deserialization_of_Post_Operation_does_not_throw_an_exception() { var response = File.ReadAllText(Path.Combine(TestContext.CurrentContext.TestDirectory, "TestData/PostOperation.json")); + using (var stream = StreamHelper.GenerateStreamFromString(response)) { var test = this.serializer.Deserialize(stream); @@ -147,25 +148,21 @@ public override void ConstructFromOperation(Operation operation) /// /// Gets or sets the collection of DTOs to delete. /// - [JsonProperty("_delete")] public override List Delete { get; set; } /// /// Gets or sets the collection of DTOs to create. /// - [JsonProperty("_create")] public override List Create { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_update")] public override List Update { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_copy")] public override List Copy { get; set; } } } diff --git a/CDP4ServicesDal.Tests/CdpServicesDalTestFixture.cs b/CDP4ServicesDal.Tests/CdpServicesDalTestFixture.cs index b85a2af1..b6cef9f2 100644 --- a/CDP4ServicesDal.Tests/CdpServicesDalTestFixture.cs +++ b/CDP4ServicesDal.Tests/CdpServicesDalTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal.Tests { @@ -38,6 +38,7 @@ namespace CDP4ServicesDal.Tests using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; + using CDP4Common.MetaInfo; using CDP4Common.SiteDirectoryData; using CDP4Common.Types; @@ -47,9 +48,10 @@ namespace CDP4ServicesDal.Tests using CDP4Dal.Exceptions; using CDP4Dal.Operations; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Operations; + using CDP4DalCommon.Protocol.Tasks; - using Newtonsoft.Json; + using CDP4JsonSerializer; using NUnit.Framework; @@ -76,13 +78,14 @@ public class CdpServicesDalTestFixture private SiteReferenceDataLibrary siteReferenceDataLibrary; private ModelReferenceDataLibrary modelReferenceDataLibrary; private CDPMessageBus messageBus; + private Cdp4JsonSerializer jsonSerializer; [SetUp] public void Setup() { this.cancelationTokenSource = new CancellationTokenSource(); - - this.credentials = new Credentials("admin", "pass", this.uri, true); + + this.credentials = new Credentials("admin", "pass", this.uri); this.dal = new CdpServicesDal(); this.messageBus = new CDPMessageBus(); this.session = new Session(this.dal, this.credentials, this.messageBus); @@ -91,7 +94,8 @@ public void Setup() this.siteDirectory = new SiteDirectory(Guid.Parse("f13de6f8-b03a-46e7-a492-53b2f260f294"), this.session.Assembler.Cache, this.uri); var lazySiteDirectory = new Lazy(() => this.siteDirectory); lazySiteDirectory.Value.Cache.TryAdd(new CacheKey(lazySiteDirectory.Value.Iid, null), lazySiteDirectory); - + var metaDataProvider = new MetaDataProvider(); + this.jsonSerializer = new Cdp4JsonSerializer(metaDataProvider, metaDataProvider.GetMaxSupportedModelVersion()); this.PopulateSiteDirectory(); } @@ -228,17 +232,18 @@ public void VerifyThatDalThatIsNotOpenCannotBeClosed() Assert.Throws(() => this.dal.Close()); } - [Test] + [TestCase(true)] + [TestCase(false)] [Category("WebServicesDependent")] - public async Task VerifyThatReadReturnsCorrectDTO() + public async Task VerifyThatReadReturnsCorrectDTO(bool isMessagePackSupported) { - this.dal = new CdpServicesDal(); + this.dal = new CdpServicesDal(isMessagePackSupported); var returned = (await this.dal.Open(this.credentials, this.cancelationTokenSource.Token)).ToList(); Assert.That(returned, Is.Not.Null); Assert.That(returned, Is.Not.Empty); - var sd = returned.OfType().First(); + var sd = returned.First(x => x.ClassKind == ClassKind.SiteDirectory); var attributes = new QueryAttributes(); var readResult = await this.dal.Read(sd, this.cancelationTokenSource.Token, attributes); @@ -723,7 +728,7 @@ public async Task Verify_that_person_can_be_Posted() Assert.That(resultPerson, Is.Not.Null); } - [Test] + [Test] public async Task VerifyReadCometTask() { var mockHttp = new MockHttpMessageHandler(); @@ -732,7 +737,7 @@ public async Task VerifyReadCometTask() this.dal = new CdpServicesDal(httpClient); this.SetDalToBeOpen(this.dal); - + var cometTaskId = Guid.NewGuid(); var requestHandler = mockHttp.When($"{CdpServicesDal.CometTaskRoute}/{cometTaskId}"); @@ -758,7 +763,7 @@ public async Task VerifyReadCometTask() StatusKind = StatusKind.SUCCEEDED }; - foundHttpResponse.Content = new StringContent(JsonConvert.SerializeObject(cometTask)); + foundHttpResponse.Content = new StringContent(this.jsonSerializer.SerializeToString(cometTask)); SetHttpHeader(foundHttpResponse, "application/json"); var readCometTask = await this.dal.ReadCometTask(cometTaskId, CancellationToken.None); @@ -766,7 +771,7 @@ public async Task VerifyReadCometTask() var messagePackHttpResponse = new HttpResponseMessage(); requestHandler.Respond(_ => messagePackHttpResponse); - messagePackHttpResponse.Content = new StringContent(JsonConvert.SerializeObject(cometTask)); + messagePackHttpResponse.Content = new StringContent(this.jsonSerializer.SerializeToString(cometTask)); SetHttpHeader(messagePackHttpResponse, "application/msgpack"); Assert.That(() => this.dal.ReadCometTask(cometTaskId, CancellationToken.None), Throws.Exception.TypeOf()); @@ -781,7 +786,7 @@ public async Task VerifyReadCometTasks() this.dal = new CdpServicesDal(httpClient); this.SetDalToBeOpen(this.dal); - + var requestHandler = mockHttp.When($"{CdpServicesDal.CometTaskRoute}"); var notFoundHttpResponse = new HttpResponseMessage() @@ -808,7 +813,7 @@ public async Task VerifyReadCometTasks() } }; - foundHttpResponse.Content = new StringContent(JsonConvert.SerializeObject(cometTasks)); + foundHttpResponse.Content = new StringContent(this.jsonSerializer.SerializeToString(cometTasks)); SetHttpHeader(foundHttpResponse, "application/json"); var readCometTasks = await this.dal.ReadCometTasks(CancellationToken.None); @@ -816,7 +821,7 @@ public async Task VerifyReadCometTasks() var messagePackHttpResponse = new HttpResponseMessage(); requestHandler.Respond(_ => messagePackHttpResponse); - messagePackHttpResponse.Content = new StringContent(JsonConvert.SerializeObject(cometTasks)); + messagePackHttpResponse.Content = new StringContent(this.jsonSerializer.SerializeToString(cometTasks)); SetHttpHeader(messagePackHttpResponse, "application/msgpack"); Assert.That(() => this.dal.ReadCometTasks(CancellationToken.None), Throws.Exception.TypeOf()); @@ -862,10 +867,10 @@ public async Task VerifyWriteLongRunningTask() var newCometTaskResponse = new HttpResponseMessage(); requestHandler.Respond(_ => newCometTaskResponse); - newCometTaskResponse.Content = new StringContent(JsonConvert.SerializeObject(cometTask)); + newCometTaskResponse.Content = new StringContent(this.jsonSerializer.SerializeToString(cometTask)); SetHttpHeader(newCometTaskResponse, "application/json"); - var longRunningTaskResult = await this.dal.Write(operationContainer,1); + var longRunningTaskResult = await this.dal.Write(operationContainer, 1); Assert.Multiple(() => { @@ -883,7 +888,7 @@ public async Task VerifyWriteLongRunningTask() thingsResponse.Content = new StreamContent(stream); SetHttpHeader(thingsResponse, "application/json"); - longRunningTaskResult = await this.dal.Write(operationContainer,1); + longRunningTaskResult = await this.dal.Write(operationContainer, 1); Assert.Multiple(() => { @@ -895,7 +900,7 @@ public async Task VerifyWriteLongRunningTask() var messagePackResponse = new HttpResponseMessage(); requestHandler.Respond(_ => messagePackResponse); - messagePackResponse.Content = new StringContent(JsonConvert.SerializeObject(cometTask)); + messagePackResponse.Content = new StringContent(this.jsonSerializer.SerializeToString(cometTask)); SetHttpHeader(messagePackResponse, "application/msgpack"); Assert.That(() => this.dal.Write(operationContainer, 1), Throws.Exception.TypeOf()); } diff --git a/CDP4ServicesDal.Tests/CopyOperationHandlerTestFixture.cs b/CDP4ServicesDal.Tests/CopyOperationHandlerTestFixture.cs index ffd0198e..95937a83 100644 --- a/CDP4ServicesDal.Tests/CopyOperationHandlerTestFixture.cs +++ b/CDP4ServicesDal.Tests/CopyOperationHandlerTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal.Tests { @@ -36,6 +36,8 @@ namespace CDP4ServicesDal.Tests using CDP4Dal.Operations; using CDP4Dal.Permission; + using CDP4DalCommon.Protocol.Operations; + using Moq; using NUnit.Framework; diff --git a/CDP4ServicesDal.Tests/OperationModifierTestFixture.cs b/CDP4ServicesDal.Tests/OperationModifierTestFixture.cs index 02586edd..14126514 100644 --- a/CDP4ServicesDal.Tests/OperationModifierTestFixture.cs +++ b/CDP4ServicesDal.Tests/OperationModifierTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal.Tests { @@ -34,6 +34,8 @@ namespace CDP4ServicesDal.Tests using CDP4Dal; using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + using Moq; using NUnit.Framework; diff --git a/CDP4ServicesDal.Tests/PostOperationTestFixture.cs b/CDP4ServicesDal.Tests/PostOperationTestFixture.cs index e4c06b07..ce856018 100644 --- a/CDP4ServicesDal.Tests/PostOperationTestFixture.cs +++ b/CDP4ServicesDal.Tests/PostOperationTestFixture.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft, Yevhen Ikonnykov -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal.Tests { @@ -35,14 +35,14 @@ namespace CDP4ServicesDal.Tests using CDP4Common.MetaInfo; using CDP4Common.Types; - using CDP4JsonSerializer; - using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + + using CDP4DalJsonSerializer; + using CDP4ServicesDal.Tests.Helper; - - using Newtonsoft.Json; - + using NUnit.Framework; using File = System.IO.File; @@ -50,19 +50,20 @@ namespace CDP4ServicesDal.Tests [TestFixture] public class PostOperationTestFixture { - private Cdp4JsonSerializer serializer; + private Cdp4DalJsonSerializer serializer; [SetUp] public void Setup() { var metamodel = new MetaDataProvider(); - this.serializer = new Cdp4JsonSerializer(metamodel, new Version(1, 1, 0)); + this.serializer = new Cdp4DalJsonSerializer(metamodel, new Version(1, 1, 0)); } [Test] public void Verify_that_deserialization_of_Post_Operation_does_not_throw_an_exception() { var response = File.ReadAllText(Path.Combine(TestContext.CurrentContext.TestDirectory, "TestData/PostOperation.json")); + using (var stream = StreamHelper.GenerateStreamFromString(response)) { var test = this.serializer.Deserialize(stream); @@ -88,7 +89,7 @@ public void Verify_that_serialization_of_Post_Operation_returns_expected_result( originalDomainFileStore.AddContainer(ClassKind.Iteration, iterationIid); originalDomainFileStore.AddContainer(ClassKind.EngineeringModel, engineeringModelIid); - var modifiedDomainFileStore = originalDomainFileStore.DeepClone(); + var modifiedDomainFileStore = originalDomainFileStore.DeepClone(); modifiedDomainFileStore.File.Add(fileIid); var file = new CDP4Common.DTO.File(fileIid, 0); @@ -101,7 +102,7 @@ public void Verify_that_serialization_of_Post_Operation_returns_expected_result( var fileRevision = new FileRevision(fileRevisionIid, 0); fileRevision.Name = "testfile"; fileRevision.ContentHash = "F73747371CFD9473C19A0A7F99BCAB008474C4CA"; - fileRevision.FileType.Add(new OrderedItem() {K = 1, V = fileTypeIid }); + fileRevision.FileType.Add(new OrderedItem() { K = 1, V = fileTypeIid }); fileRevision.Creator = participantIid; fileRevision.AddContainer(ClassKind.File, fileIid); fileRevision.AddContainer(ClassKind.DomainFileStore, domainFileStoreIid); @@ -122,7 +123,8 @@ public void Verify_that_serialization_of_Post_Operation_returns_expected_result( var postOperation = new CdpPostOperation(new MetaDataProvider(), null); - foreach (var operation in operationContainer.Operations) { + foreach (var operation in operationContainer.Operations) + { postOperation.ConstructFromOperation(operation); } @@ -146,25 +148,21 @@ public override void ConstructFromOperation(Operation operation) /// /// Gets or sets the collection of DTOs to delete. /// - [JsonProperty("_delete")] public override List Delete { get; set; } /// /// Gets or sets the collection of DTOs to create. /// - [JsonProperty("_create")] public override List Create { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_update")] public override List Update { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_copy")] public override List Copy { get; set; } } } diff --git a/CDP4ServicesDal/CDP4ServicesDal.csproj b/CDP4ServicesDal/CDP4ServicesDal.csproj index 7475c171..03cbb16f 100644 --- a/CDP4ServicesDal/CDP4ServicesDal.csproj +++ b/CDP4ServicesDal/CDP4ServicesDal.csproj @@ -27,6 +27,7 @@ + @@ -39,13 +40,9 @@ - - - - - + diff --git a/CDP4ServicesDal/CdpPostOperation.cs b/CDP4ServicesDal/CdpPostOperation.cs index 5c5273ca..afe1adf8 100644 --- a/CDP4ServicesDal/CdpPostOperation.cs +++ b/CDP4ServicesDal/CdpPostOperation.cs @@ -1,28 +1,26 @@ -#region Copyright -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- -#endregion +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal { @@ -30,16 +28,19 @@ namespace CDP4ServicesDal using System.Collections; using System.Collections.Generic; using System.Linq; + using CDP4Common; using CDP4Common.CommonData; using CDP4Common.Dto; using CDP4Common.EngineeringModelData; - using CDP4Common.MetaInfo; + using CDP4Common.MetaInfo; using CDP4Common.SiteDirectoryData; using CDP4Common.Types; + using CDP4Dal; using CDP4Dal.Operations; - using Newtonsoft.Json; + + using CDP4DalCommon.Protocol.Operations; /// /// The CDP POST operation @@ -81,25 +82,21 @@ internal CdpPostOperation(IMetaDataProvider metaDataProvider, ISession session) /// /// Gets or sets the collection of DTOs to delete. /// - [JsonProperty("_delete")] public override List Delete { get; set; } /// /// Gets or sets the collection of DTOs to create. /// - [JsonProperty("_create")] public override List Create { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_update")] public override List Update { get; set; } /// /// Gets or sets the collection of DTOs to copy. /// - [JsonProperty("_copy")] public override List Copy { get; set; } /// @@ -154,6 +151,7 @@ private void ResolveUpdate(Operation operation) foreach (var key in original.Keys) { var originalIenumerable = original[key] as IEnumerable; + if (originalIenumerable != null && originalIenumerable.GetType().IsGenericType) { var modifiedIenumerable = (IEnumerable)modifiedFull[key]; @@ -177,6 +175,7 @@ private void ResolveUpdate(Operation operation) List modifiedProperty; var genericTypeArgument = original[key].GetType().GenericTypeArguments[0]; + if (genericTypeArgument == typeof(Guid) || genericTypeArgument == typeof(ClassKind) || genericTypeArgument == typeof(VcardTelephoneNumberKind)) { originalProperty = originalIenumerable.Cast().ToList(); @@ -221,6 +220,7 @@ private void ResolveUpdate(Operation operation) } var possibleDeletions = originalProperty.Except(modifiedProperty).ToList(); + if (possibleDeletions.Count > 0) { // this part will be added to the delete @@ -275,6 +275,7 @@ private void ResolveUpdate(Operation operation) if (listsToAdd.Count > 0) { var updateDto = modified; + foreach (var kvp in listsToAdd) { updateDto.Add(kvp.Key, kvp.Value); @@ -311,18 +312,20 @@ private void ResolveCopy(Operation operation) var source = new CopySource { - Thing = new CopyReference {Iid = operation.OriginalThing.Iid, ClassKind = operation.OriginalThing.ClassKind}, - TopContainer = new CopyReference {Iid = sourcepoco.TopContainer.Iid, ClassKind = sourcepoco.TopContainer.ClassKind}, + Thing = new CopyReference { Iid = operation.OriginalThing.Iid, ClassKind = operation.OriginalThing.ClassKind }, + TopContainer = new CopyReference { Iid = sourcepoco.TopContainer.Iid, ClassKind = sourcepoco.TopContainer.ClassKind }, IterationId = sourceIteration?.Iid }; var poco = operation.ModifiedThing.QuerySourceThing(); + if (poco.Container == null) { throw new InvalidOperationException("The container cannot be null."); } var targetIteration = poco.GetContainerOfType(); + var target = new CopyTarget { Container = new CopyReference { Iid = poco.Container.Iid, ClassKind = poco.Container.ClassKind }, diff --git a/CDP4ServicesDal/CdpServicesDal.cs b/CDP4ServicesDal/CdpServicesDal.cs index adc8222f..5d8046ee 100644 --- a/CDP4ServicesDal/CdpServicesDal.cs +++ b/CDP4ServicesDal/CdpServicesDal.cs @@ -2,7 +2,7 @@ // // Copyright (c) 2015-2024 Starion Group S.A. // -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -27,7 +27,6 @@ namespace CDP4ServicesDal #if NETFRAMEWORK using System.ComponentModel.Composition; #endif - using System; using System.Collections.Generic; using System.Diagnostics; @@ -45,8 +44,6 @@ namespace CDP4ServicesDal using CDP4Common.DTO; using CDP4Common.Extensions; - using CDP4DalCommon.Tasks; - using CDP4Dal; using CDP4Dal.Composition; using CDP4Dal.DAL; @@ -54,7 +51,10 @@ namespace CDP4ServicesDal using CDP4Dal.Exceptions; using CDP4Dal.Operations; - using CDP4JsonSerializer; + using CDP4DalCommon.Protocol.Operations; + using CDP4DalCommon.Protocol.Tasks; + + using CDP4DalJsonSerializer; using CDP4MessagePackSerializer; @@ -89,13 +89,21 @@ public class CdpServicesDal : Dal /// private HttpClient httpClient; + /// + /// Asserts that the MessagePack deserialization should be used or not + /// + private readonly bool isMessagePackSupported; + /// /// Initializes a new instance of the class. /// - public CdpServicesDal() + /// Asserts that the MessagePack deserialization should be used or not. Supported by default + public CdpServicesDal(bool isMessagePackSupported = true) { - this.Cdp4JsonSerializer = new Cdp4JsonSerializer(this.MetaDataProvider, this.DalVersion); + this.Cdp4JsonSerializer = new Cdp4DalJsonSerializer(this.MetaDataProvider, this.DalVersion); this.MessagePackSerializer = new MessagePackSerializer(); + + this.isMessagePackSupported = isMessagePackSupported; } /// @@ -104,7 +112,8 @@ public CdpServicesDal() /// /// The (injected) /// - public CdpServicesDal(HttpClient httpClient) : this() + /// Asserts that the MessagePack deserialization should be used or not. Supported by default + public CdpServicesDal(HttpClient httpClient, bool isMessagePackSupported = true) : this(isMessagePackSupported) { if (httpClient == null) { @@ -115,9 +124,9 @@ public CdpServicesDal(HttpClient httpClient) : this() } /// - /// Gets the + /// Gets the /// - public Cdp4JsonSerializer Cdp4JsonSerializer { get; private set; } + public Cdp4DalJsonSerializer Cdp4JsonSerializer { get; private set; } /// /// Gets the @@ -342,7 +351,7 @@ public override async Task Write(OperationContainer opera case ContentTypeKind.MESSAGEPACK: throw new NotSupportedException("Long running task not supported with MESSAGEPACK"); default: - throw new InvalidOperationException( $"ContentTypeKind {contentTypeKind} not supported"); + throw new InvalidOperationException($"ContentTypeKind {contentTypeKind} not supported"); } deserializationWatch.Stop(); @@ -735,7 +744,7 @@ public override async Task ReadCometTask(Guid id, CancellationToken c case ContentTypeKind.MESSAGEPACK: throw new NotSupportedException("Read CometTask by id not supported with MESSAGEPACK"); default: - throw new InvalidOperationException( $"ContentTypeKind {contentTypeKind} not supported"); + throw new InvalidOperationException($"ContentTypeKind {contentTypeKind} not supported"); } deserializationWatch.Stop(); @@ -796,7 +805,7 @@ public override async Task> ReadCometTasks(CancellationTo case ContentTypeKind.MESSAGEPACK: throw new NotSupportedException("Read all CometTask not supported with MESSAGEPACK"); default: - throw new InvalidOperationException( $"ContentTypeKind {contentTypeKind} not supported"); + throw new InvalidOperationException($"ContentTypeKind {contentTypeKind} not supported"); } deserializationWatch.Stop(); @@ -1089,8 +1098,13 @@ private HttpClient CreateHttpClient(Credentials credentials, HttpClient injected result.BaseAddress = credentials.Uri; result.DefaultRequestHeaders.Accept.Clear(); result.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); - result.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/msgpack")); - result.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes($"{credentials.UserName}:{credentials.Password}"))); + + if (this.isMessagePackSupported) + { + result.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/msgpack")); + } + + result.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes($"{credentials.UserName}:{credentials.Password}"))); result.DefaultRequestHeaders.Add(Headers.AcceptCdpVersion, Headers.AcceptCdpVersionValue); result.DefaultRequestHeaders.Add("User-Agent", "CDP4 (ECSS-E-TM-10-25 Annex C.2) CDPServicesDal"); @@ -1402,8 +1416,8 @@ private LongRunningTaskResult ExtractResultFromStream(Stream stream) var firstChar = (char)reader.Peek(); stream.Position = 0; - return firstChar == '[' - ? new LongRunningTaskResult(this.Cdp4JsonSerializer.Deserialize(stream)) + return firstChar == '[' + ? new LongRunningTaskResult(this.Cdp4JsonSerializer.Deserialize(stream)) : new LongRunningTaskResult(this.Cdp4JsonSerializer.Deserialize(stream)); } } diff --git a/CDP4ServicesDal/CopyOperationHandler.cs b/CDP4ServicesDal/CopyOperationHandler.cs index 7b077bd9..4596d0fb 100644 --- a/CDP4ServicesDal/CopyOperationHandler.cs +++ b/CDP4ServicesDal/CopyOperationHandler.cs @@ -1,26 +1,26 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal { @@ -31,12 +31,13 @@ namespace CDP4ServicesDal using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; - using CDP4Common.Helpers; using CDP4Dal; using CDP4Dal.Operations; using CDP4Dal.Permission; + using CDP4DalCommon.Protocol.Operations; + using Poco = CDP4Common.CommonData.Thing; /// @@ -55,7 +56,7 @@ internal class CopyOperationHandler private readonly ISession session; /// - /// A that map the original to the copied version + /// A that map the original to the copied version /// private Dictionary copyThingMap; @@ -95,6 +96,7 @@ public void ModifiedCopyOperation(OperationContainer operationContainer) var operationsToAdd = new List(); var copyOperationCount = operationContainer.Operations.Count(x => x.OperationKind.IsCopyOperation()); + if (copyOperationCount > 1) { // TODO: support this if needed @@ -102,6 +104,7 @@ public void ModifiedCopyOperation(OperationContainer operationContainer) } var copyOperation = operationContainer.Operations.SingleOrDefault(x => x.OperationKind.IsCopyOperation()); + if (copyOperation == null) { return; @@ -156,6 +159,7 @@ private void ComputeOperations(Operation copyOperation) // Add all contained objects this.copyableIds.AddRange(copyPermissionResult.CopyableThings.Select(c => c.Iid).ToList()); + if (this.copyableIds.Contains(originalPoco.Iid)) { var updatedIteration = copyPoco.GetContainerOfType(); @@ -164,6 +168,7 @@ private void ComputeOperations(Operation copyOperation) // modify the references to point to the copy thing this.ModifyReferences(); + if (copyOperation.OperationKind.IsCopyChangeOwnerOperation()) { this.ChangeOwner(updatedIteration); @@ -209,6 +214,7 @@ private void CreatePocoCopy(Poco poco, Iteration targetIteration) foreach (var containerList in poco.ContainerLists) { var updatedContainerList = new List(); + foreach (Poco containedPoco in containerList) { if (!this.copyableIds.Contains(containedPoco.Iid)) @@ -311,6 +317,7 @@ private void ModifyReferences(ElementUsage usage) private void ModifyReferences(Parameter parameter) { parameter.StateDependence = null; + if (parameter.Group == null) { return; @@ -319,6 +326,7 @@ private void ModifyReferences(Parameter parameter) // if the group cannot be copied, set to null Poco groupCopy; this.copyThingMap.TryGetValue(parameter.Group, out groupCopy); + parameter.Group = this.copyThingMap.TryGetValue(parameter.Group, out groupCopy) ? (ParameterGroup)groupCopy : null; @@ -338,6 +346,7 @@ private void ModifyReferences(ParameterGroup group) // if the group cannot be copied, set to null Poco groupCopy; this.copyThingMap.TryGetValue(group.ContainingGroup, out groupCopy); + group.ContainingGroup = this.copyThingMap.TryGetValue(group.ContainingGroup, out groupCopy) ? (ParameterGroup)groupCopy : null; @@ -361,12 +370,14 @@ private void ModifyReferences(ParameterOverride parameterOverride) private void ChangeOwner(Iteration iteration) { var activeDomain = this.session.OpenIterations.Single(x => x.Key.Iid == iteration.Iid).Value.Item1; + if (activeDomain == null) { throw new InvalidOperationException("The active domain is null. The copy operation cannot be performed."); } var ownedThings = this.copyThingMap.Values.OfType().ToList(); + foreach (var ownedThing in ownedThings) { // the owner of a subscription shall not be set to the active one @@ -379,4 +390,4 @@ private void ChangeOwner(Iteration iteration) } } } -} \ No newline at end of file +} diff --git a/CDP4ServicesDal/OperationModifier.cs b/CDP4ServicesDal/OperationModifier.cs index c3d1637f..c1c91970 100644 --- a/CDP4ServicesDal/OperationModifier.cs +++ b/CDP4ServicesDal/OperationModifier.cs @@ -1,44 +1,42 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal { - using System; using System.Collections.Generic; using System.Linq; - using CDP4Common.CommonData; + using CDP4Common.EngineeringModelData; - using CDP4Common.Types; + using CDP4Dal; using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + using ActualFiniteState = CDP4Common.DTO.ActualFiniteState; - using ElementUsage = CDP4Common.DTO.ElementUsage; - using ParameterOverride = CDP4Common.DTO.ParameterOverride; - using ParameterSubscription = CDP4Common.DTO.ParameterSubscription; using PossibleFiniteStateList = CDP4Common.DTO.PossibleFiniteStateList; - + /// /// The purpose of the is to perform operations that /// are not performed directly by the server @@ -73,6 +71,7 @@ public void ModifyOperationContainer(OperationContainer operationContainer) if (operation.OperationKind == OperationKind.Update) { var possibleStateList = operation.ModifiedThing as PossibleFiniteStateList; + if (possibleStateList != null) { operationsToAdd.AddRange(this.ModifyActualStateKindOnDefaultPossibleStateUpdate(possibleStateList)); @@ -95,6 +94,7 @@ private IEnumerable ModifyActualStateKindOnDefaultPossibleStateUpdate { var operations = new List(); var defaultStateId = possibleFiniteStateList.DefaultState; + if (!defaultStateId.HasValue) { return operations; @@ -102,14 +102,15 @@ private IEnumerable ModifyActualStateKindOnDefaultPossibleStateUpdate // gets the actualList that uses the updated possible list var actualLists = this.session.Assembler.Cache.Select(x => x.Value) - .Select(x => x.Value) - .OfType() - .Where(x => x.PossibleFiniteStateList.Select(pl => pl.Iid).Contains(possibleFiniteStateList.Iid)) - .ToList(); + .Select(x => x.Value) + .OfType() + .Where(x => x.PossibleFiniteStateList.Select(pl => pl.Iid).Contains(possibleFiniteStateList.Iid)) + .ToList(); foreach (var actualFiniteStateList in actualLists) { var possibleLists = actualFiniteStateList.PossibleFiniteStateList.Where(x => x.Iid != possibleFiniteStateList.Iid).ToList(); + if (possibleLists.Any(x => x.DefaultState == null)) { // one of the possible list has no default state @@ -141,4 +142,4 @@ private IEnumerable ModifyActualStateKindOnDefaultPossibleStateUpdate return operations; } } -} \ No newline at end of file +} diff --git a/CDP4ServicesDal/ValueSetOperationCreator.cs b/CDP4ServicesDal/ValueSetOperationCreator.cs index 9b20d996..06beb83a 100644 --- a/CDP4ServicesDal/ValueSetOperationCreator.cs +++ b/CDP4ServicesDal/ValueSetOperationCreator.cs @@ -1,38 +1,41 @@ -#region Copyright -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- -#endregion +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4ServicesDal { using System; using System.Collections.Generic; using System.Linq; + using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; + using CDP4Dal; using CDP4Dal.Operations; + + using CDP4DalCommon.Protocol.Operations; + using Dto = CDP4Common.DTO; /// @@ -44,7 +47,7 @@ internal class ValueSetOperationCreator /// The associated /// private readonly ISession session; - + /// /// Initializes a new instance of the class /// @@ -70,6 +73,7 @@ public OperationContainer CreateValueSetsUpdateOperations(string context, IEnume var dtolist = dtos.ToList(); var topContainer = dtolist.SingleOrDefault(x => x is Dto.TopContainer); + if (topContainer == null) { throw new InvalidOperationException("No Top container were found in the returned list of dtos."); @@ -78,9 +82,10 @@ public OperationContainer CreateValueSetsUpdateOperations(string context, IEnume // Gets the parameter base which value set shall be updated var copyParameterBases = dtolist.OfType().ToList(); var copyParameterBasesIds = copyParameterBases.Select(p => p.Iid).ToList(); + var valuesets = dtolist.Where(dto => dto.ClassKind == ClassKind.ParameterValueSet || - dto.ClassKind == ClassKind.ParameterSubscriptionValueSet || - dto.ClassKind == ClassKind.ParameterOverrideValueSet).ToList(); + dto.ClassKind == ClassKind.ParameterSubscriptionValueSet || + dto.ClassKind == ClassKind.ParameterOverrideValueSet).ToList(); this.ComputeRoutes(valuesets, dtolist); var valueSetsClones = valuesets.Select(dto => dto.DeepClone()).ToList(); @@ -98,6 +103,7 @@ public OperationContainer CreateValueSetsUpdateOperations(string context, IEnume // value sets to update var copyValueSets = valueSetsClones.Where(x => copyDto.ValueSets.Contains(x.Iid)).ToList(); var defaultValueSet = this.GetDefaultValueSet(originalParameter); + if (defaultValueSet == null) { continue; @@ -107,6 +113,7 @@ public OperationContainer CreateValueSetsUpdateOperations(string context, IEnume } var operationContainer = new OperationContainer(context, topContainer.RevisionNumber); + foreach (var valueSetsClone in valueSetsClones) { var valuesetToUpdate = valuesets.Single(x => x.Iid == valueSetsClone.Iid); @@ -203,4 +210,4 @@ private void SetValueSetValues(Dto.ParameterSubscriptionValueSet valueSet, Param valueSet.ValueSwitch = originalValueSet.ValueSwitch; } } -} \ No newline at end of file +} diff --git a/CDP4ServicesMessaging/CDP4ServicesMessaging.csproj b/CDP4ServicesMessaging/CDP4ServicesMessaging.csproj index f34412c1..1e683a06 100644 --- a/CDP4ServicesMessaging/CDP4ServicesMessaging.csproj +++ b/CDP4ServicesMessaging/CDP4ServicesMessaging.csproj @@ -1,4 +1,4 @@ - + netstandard2.0 diff --git a/CDP4ServicesMessaging/Serializers/Json/Cdp4MessageSerializer.cs b/CDP4ServicesMessaging/Serializers/Json/Cdp4MessageSerializer.cs index 0eeae080..7504aba4 100644 --- a/CDP4ServicesMessaging/Serializers/Json/Cdp4MessageSerializer.cs +++ b/CDP4ServicesMessaging/Serializers/Json/Cdp4MessageSerializer.cs @@ -1,21 +1,21 @@ // ------------------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2023 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Antoine Théate, Nathanael Smiechowski -// -// This file is part of COMET-SDK Community Edition -// -// The CDP4-COMET-SDK Community Edition is free software; you can redistribute it and/or +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-COMET-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. @@ -27,13 +27,12 @@ namespace CDP4ServicesMessaging.Serializers.Json using System; using System.Diagnostics; using System.IO; - + using System.Text.Json; + using CDP4Common.MetaInfo; using CDP4JsonSerializer; - using Newtonsoft.Json; - using NLog; /// @@ -58,7 +57,7 @@ public Cdp4MessageSerializer() /// /// The public Cdp4MessageSerializer(IMetaDataProvider metaInfoProvider) : base(metaInfoProvider, metaInfoProvider.GetMaxSupportedModelVersion()) - { + { } /// @@ -70,27 +69,22 @@ public Cdp4MessageSerializer(IMetaDataProvider metaInfoProvider) : base(metaInfo public ReadOnlyMemory Serialize(T message) { var sw = Stopwatch.StartNew(); - var serializer = this.CreateJsonSerializer(); // Use a MemoryStream to store the serialized data using var memoryStream = new MemoryStream(); - Logger.Trace("initializing JsonTextWriter"); - using var jsonWriter = new JsonTextWriter(new StreamWriter(memoryStream)); - Logger.Trace("Serialize to JsonTextWriter"); - serializer.Serialize(jsonWriter, message); - jsonWriter.Flush(); + JsonSerializer.Serialize(memoryStream, message, this.JsonSerializerOptions); // Get the ReadOnlyMemory from the MemoryStream var serializedMessage = new ReadOnlyMemory(memoryStream.ToArray()); sw.Stop(); Logger.Debug("SerializeThingsChangedMessage finished in {0} [ms]", sw.ElapsedMilliseconds); - + return serializedMessage; } - + /// /// Deserializes a message of type from the specified . /// diff --git a/CDP4WspDal.NetCore.Tests/CopyOperationHandlerTestFixture.cs b/CDP4WspDal.NetCore.Tests/CopyOperationHandlerTestFixture.cs index af924e2a..dd8b202f 100644 --- a/CDP4WspDal.NetCore.Tests/CopyOperationHandlerTestFixture.cs +++ b/CDP4WspDal.NetCore.Tests/CopyOperationHandlerTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal.Tests { @@ -36,6 +36,8 @@ namespace CDP4WspDal.Tests using CDP4Dal.Operations; using CDP4Dal.Permission; + using CDP4DalCommon.Protocol.Operations; + using Moq; using NUnit.Framework; diff --git a/CDP4WspDal.NetCore.Tests/OperationModifierTestFixture.cs b/CDP4WspDal.NetCore.Tests/OperationModifierTestFixture.cs index 76349058..3271a2c5 100644 --- a/CDP4WspDal.NetCore.Tests/OperationModifierTestFixture.cs +++ b/CDP4WspDal.NetCore.Tests/OperationModifierTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal.Tests { @@ -34,6 +34,8 @@ namespace CDP4WspDal.Tests using CDP4Dal; using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + using Moq; using NUnit.Framework; diff --git a/CDP4WspDal.NetCore.Tests/Operations/WSPPostOperationTestFixture.cs b/CDP4WspDal.NetCore.Tests/Operations/WSPPostOperationTestFixture.cs index 02ebbedf..612d25e3 100644 --- a/CDP4WspDal.NetCore.Tests/Operations/WSPPostOperationTestFixture.cs +++ b/CDP4WspDal.NetCore.Tests/Operations/WSPPostOperationTestFixture.cs @@ -1,40 +1,38 @@ -#region Copyright -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- -#endregion +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal.Tests.Operations { using System; using System.Collections; - using System.Collections.Generic; using System.Linq; + using CDP4Common.DTO; - using CDP4Common.MetaInfo; + using CDP4Common.MetaInfo; using CDP4Common.Types; - using CDP4Dal.Operations; - using CDP4WspDal; + + using CDP4DalCommon.Protocol.Operations; using NUnit.Framework; @@ -101,7 +99,7 @@ public void VerifyThatExceptionIsThrownWhenModifiedThingIsNotProvided() { var simpleUnit = new SimpleUnit(Guid.NewGuid(), 1); var operation = new Operation(simpleUnit, null, OperationKind.Delete); - Assert.Throws(() => this.wspPostOperation.ConstructFromOperation(operation)) ; + Assert.Throws(() => this.wspPostOperation.ConstructFromOperation(operation)); } [Test] diff --git a/CDP4WspDal.NetCore.Tests/PostOperationTestFixture.cs b/CDP4WspDal.NetCore.Tests/PostOperationTestFixture.cs index b6a7815e..4008a4eb 100644 --- a/CDP4WspDal.NetCore.Tests/PostOperationTestFixture.cs +++ b/CDP4WspDal.NetCore.Tests/PostOperationTestFixture.cs @@ -1,61 +1,70 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft, Yevhen Ikonnykov -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal.Tests { using System; using System.Collections.Generic; using System.IO; + using CDP4Common; + using CDP4Common.CommonData; using CDP4Common.Dto; + using CDP4Common.DTO; using CDP4Common.MetaInfo; - using CDP4JsonSerializer; + using CDP4Common.Types; + using CDP4Dal.Operations; + + using CDP4DalCommon.Protocol.Operations; + + using CDP4DalJsonSerializer; + using CDP4WspDal.Tests.Helper; - using Newtonsoft.Json; + using NUnit.Framework; - using CDP4Common.DTO; - using CDP4Common.CommonData; - using CDP4Common.Types; + using File = System.IO.File; + using Thing = CDP4Common.DTO.Thing; [TestFixture] public class PostOperationTestFixture { - private Cdp4JsonSerializer serializer; + private Cdp4DalJsonSerializer serializer; [SetUp] public void Setup() { var metamodel = new MetaDataProvider(); - this.serializer = new Cdp4JsonSerializer(metamodel, new Version(1, 1, 0)); + this.serializer = new Cdp4DalJsonSerializer(metamodel, new Version(1, 1, 0), true); } [Test] public void Verify_that_deserialization_of_Post_Operation_does_not_throw_an_exception() { var response = File.ReadAllText(Path.Combine(TestContext.CurrentContext.TestDirectory, "TestData/PostOperation.json")); + using (var stream = StreamHelper.GenerateStreamFromString(response)) { Assert.DoesNotThrow(() => this.serializer.Deserialize(stream)); @@ -93,7 +102,7 @@ public void Verify_that_serialization_of_Post_Operation_returns_expected_result( var fileRevision = new FileRevision(fileRevisionIid, 0); fileRevision.Name = "testfile"; fileRevision.ContentHash = "F73747371CFD9473C19A0A7F99BCAB008474C4CA"; - fileRevision.FileType.Add(new OrderedItem() { K = 1, V = fileTypeIid }); + fileRevision.FileType.Add(new OrderedItem { K = 1, V = fileTypeIid }); fileRevision.Creator = participantIid; fileRevision.AddContainer(ClassKind.File, fileIid); fileRevision.AddContainer(ClassKind.DomainFileStore, domainFileStoreIid); @@ -101,7 +110,7 @@ public void Verify_that_serialization_of_Post_Operation_returns_expected_result( fileRevision.AddContainer(ClassKind.EngineeringModel, engineeringModelIid); var context = $"/EngineeringModel/{engineeringModelIid}/iteration/{iterationIid}"; - var operationContainer = new OperationContainer(context, null); + var operationContainer = new OperationContainer(context); var updateCommonFileStoreOperation = new Operation(originalDomainFileStore, modifiedDomainFileStore, OperationKind.Update); operationContainer.AddOperation(updateCommonFileStoreOperation); @@ -131,34 +140,30 @@ public void Verify_that_serialization_of_Post_Operation_returns_expected_result( private class TestPostOperation : PostOperation { - public override void ConstructFromOperation(Operation operation) - { - throw new NotImplementedException(); - } - /// /// Gets or sets the collection of DTOs to delete. /// - [JsonProperty("_delete")] public override List Delete { get; set; } /// /// Gets or sets the collection of DTOs to create. /// - [JsonProperty("_create")] - public override List Create { get; set; } + public override List Create { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_update")] public override List Update { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_copy")] public override List Copy { get; set; } + + public override void ConstructFromOperation(Operation operation) + { + throw new NotImplementedException(); + } } } } diff --git a/CDP4WspDal.NetCore.Tests/WSPDalTestFixture.cs b/CDP4WspDal.NetCore.Tests/WSPDalTestFixture.cs index 07a217f1..a6fff9c6 100644 --- a/CDP4WspDal.NetCore.Tests/WSPDalTestFixture.cs +++ b/CDP4WspDal.NetCore.Tests/WSPDalTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal.Tests { @@ -45,6 +45,8 @@ namespace CDP4WspDal.Tests using CDP4Dal.DAL.ECSS1025AnnexC; using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + using NUnit.Framework; /// diff --git a/CDP4WspDal.Tests/CopyOperationHandlerTestFixture.cs b/CDP4WspDal.Tests/CopyOperationHandlerTestFixture.cs index 6f5924b7..6e38ae1a 100644 --- a/CDP4WspDal.Tests/CopyOperationHandlerTestFixture.cs +++ b/CDP4WspDal.Tests/CopyOperationHandlerTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal.Tests { @@ -36,6 +36,8 @@ namespace CDP4WspDal.Tests using CDP4Dal.Operations; using CDP4Dal.Permission; + using CDP4DalCommon.Protocol.Operations; + using Moq; using NUnit.Framework; diff --git a/CDP4WspDal.Tests/OperationModifierTestFixture.cs b/CDP4WspDal.Tests/OperationModifierTestFixture.cs index 73b00ea9..3271a2c5 100644 --- a/CDP4WspDal.Tests/OperationModifierTestFixture.cs +++ b/CDP4WspDal.Tests/OperationModifierTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal.Tests { @@ -34,6 +34,8 @@ namespace CDP4WspDal.Tests using CDP4Dal; using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + using Moq; using NUnit.Framework; diff --git a/CDP4WspDal.Tests/Operations/WSPPostOperationTestFixture.cs b/CDP4WspDal.Tests/Operations/WSPPostOperationTestFixture.cs index 02ebbedf..612d25e3 100644 --- a/CDP4WspDal.Tests/Operations/WSPPostOperationTestFixture.cs +++ b/CDP4WspDal.Tests/Operations/WSPPostOperationTestFixture.cs @@ -1,40 +1,38 @@ -#region Copyright -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- -#endregion +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal.Tests.Operations { using System; using System.Collections; - using System.Collections.Generic; using System.Linq; + using CDP4Common.DTO; - using CDP4Common.MetaInfo; + using CDP4Common.MetaInfo; using CDP4Common.Types; - using CDP4Dal.Operations; - using CDP4WspDal; + + using CDP4DalCommon.Protocol.Operations; using NUnit.Framework; @@ -101,7 +99,7 @@ public void VerifyThatExceptionIsThrownWhenModifiedThingIsNotProvided() { var simpleUnit = new SimpleUnit(Guid.NewGuid(), 1); var operation = new Operation(simpleUnit, null, OperationKind.Delete); - Assert.Throws(() => this.wspPostOperation.ConstructFromOperation(operation)) ; + Assert.Throws(() => this.wspPostOperation.ConstructFromOperation(operation)); } [Test] diff --git a/CDP4WspDal.Tests/PostOperationTestFixture.cs b/CDP4WspDal.Tests/PostOperationTestFixture.cs index 56047dfe..4008a4eb 100644 --- a/CDP4WspDal.Tests/PostOperationTestFixture.cs +++ b/CDP4WspDal.Tests/PostOperationTestFixture.cs @@ -1,61 +1,70 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexander van Delft, Yevhen Ikonnykov -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal.Tests { using System; using System.Collections.Generic; using System.IO; + using CDP4Common; + using CDP4Common.CommonData; using CDP4Common.Dto; using CDP4Common.DTO; using CDP4Common.MetaInfo; - using CDP4JsonSerializer; + using CDP4Common.Types; + using CDP4Dal.Operations; + + using CDP4DalCommon.Protocol.Operations; + + using CDP4DalJsonSerializer; + using CDP4WspDal.Tests.Helper; - using Newtonsoft.Json; + using NUnit.Framework; - using CDP4Common.Types; + using File = System.IO.File; - using CDP4Common.CommonData; + using Thing = CDP4Common.DTO.Thing; [TestFixture] public class PostOperationTestFixture { - private Cdp4JsonSerializer serializer; + private Cdp4DalJsonSerializer serializer; [SetUp] public void Setup() { var metamodel = new MetaDataProvider(); - this.serializer = new Cdp4JsonSerializer(metamodel, new Version(1, 1, 0)); + this.serializer = new Cdp4DalJsonSerializer(metamodel, new Version(1, 1, 0), true); } [Test] public void Verify_that_deserialization_of_Post_Operation_does_not_throw_an_exception() { var response = File.ReadAllText(Path.Combine(TestContext.CurrentContext.TestDirectory, "TestData/PostOperation.json")); + using (var stream = StreamHelper.GenerateStreamFromString(response)) { Assert.DoesNotThrow(() => this.serializer.Deserialize(stream)); @@ -93,7 +102,7 @@ public void Verify_that_serialization_of_Post_Operation_returns_expected_result( var fileRevision = new FileRevision(fileRevisionIid, 0); fileRevision.Name = "testfile"; fileRevision.ContentHash = "F73747371CFD9473C19A0A7F99BCAB008474C4CA"; - fileRevision.FileType.Add(new OrderedItem() { K = 1, V = fileTypeIid }); + fileRevision.FileType.Add(new OrderedItem { K = 1, V = fileTypeIid }); fileRevision.Creator = participantIid; fileRevision.AddContainer(ClassKind.File, fileIid); fileRevision.AddContainer(ClassKind.DomainFileStore, domainFileStoreIid); @@ -101,7 +110,7 @@ public void Verify_that_serialization_of_Post_Operation_returns_expected_result( fileRevision.AddContainer(ClassKind.EngineeringModel, engineeringModelIid); var context = $"/EngineeringModel/{engineeringModelIid}/iteration/{iterationIid}"; - var operationContainer = new OperationContainer(context, null); + var operationContainer = new OperationContainer(context); var updateCommonFileStoreOperation = new Operation(originalDomainFileStore, modifiedDomainFileStore, OperationKind.Update); operationContainer.AddOperation(updateCommonFileStoreOperation); @@ -128,36 +137,33 @@ public void Verify_that_serialization_of_Post_Operation_returns_expected_result( Assert.That(streamReader.ReadToEnd(), Is.EqualTo(expected)); } } + private class TestPostOperation : PostOperation { - public override void ConstructFromOperation(Operation operation) - { - throw new NotImplementedException(); - } - /// /// Gets or sets the collection of DTOs to delete. /// - [JsonProperty("_delete")] public override List Delete { get; set; } /// /// Gets or sets the collection of DTOs to create. /// - [JsonProperty("_create")] - public override List Create { get; set; } + public override List Create { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_update")] public override List Update { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_copy")] public override List Copy { get; set; } + + public override void ConstructFromOperation(Operation operation) + { + throw new NotImplementedException(); + } } } } diff --git a/CDP4WspDal.Tests/WSPDalTestFixture.cs b/CDP4WspDal.Tests/WSPDalTestFixture.cs index 43857f18..938022d5 100644 --- a/CDP4WspDal.Tests/WSPDalTestFixture.cs +++ b/CDP4WspDal.Tests/WSPDalTestFixture.cs @@ -1,8 +1,8 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2024 Starion Group S.A. -// -// Author: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar // // This file is part of CDP4-COMET SDK Community Edition // @@ -20,7 +20,7 @@ // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal.Tests { @@ -45,6 +45,8 @@ namespace CDP4WspDal.Tests using CDP4Dal.DAL.ECSS1025AnnexC; using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + using NUnit.Framework; /// diff --git a/CDP4WspDal/CDP4WspDal.csproj b/CDP4WspDal/CDP4WspDal.csproj index 781851d1..f1d12a97 100644 --- a/CDP4WspDal/CDP4WspDal.csproj +++ b/CDP4WspDal/CDP4WspDal.csproj @@ -41,7 +41,7 @@ - + diff --git a/CDP4WspDal/CopyOperationHandler.cs b/CDP4WspDal/CopyOperationHandler.cs index 49a6190d..2b66111c 100644 --- a/CDP4WspDal/CopyOperationHandler.cs +++ b/CDP4WspDal/CopyOperationHandler.cs @@ -1,28 +1,26 @@ -#region Copyright -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- -#endregion +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal { @@ -30,11 +28,16 @@ namespace CDP4WspDal using System.Collections.Generic; using System.Linq; using System.Reflection; + using CDP4Common.CommonData; using CDP4Common.EngineeringModelData; + using CDP4Dal; using CDP4Dal.Operations; using CDP4Dal.Permission; + + using CDP4DalCommon.Protocol.Operations; + using Poco = CDP4Common.CommonData.Thing; /// @@ -53,7 +56,7 @@ internal class CopyOperationHandler private readonly ISession session; /// - /// A that map the original to the copied version + /// A that map the original to the copied version /// private Dictionary copyThingMap; @@ -82,7 +85,7 @@ public CopyOperationHandler(ISession session) public IReadOnlyDictionary CopyThingMap { get { return this.copyThingMap; } - } + } /// /// Modify the if it contains copy @@ -93,6 +96,7 @@ public void ModifiedCopyOperation(OperationContainer operationContainer) var operationsToAdd = new List(); var copyOperationCount = operationContainer.Operations.Count(x => x.OperationKind.IsCopyOperation()); + if (copyOperationCount > 1) { // TODO: support this if needed @@ -100,6 +104,7 @@ public void ModifiedCopyOperation(OperationContainer operationContainer) } var copyOperation = operationContainer.Operations.SingleOrDefault(x => x.OperationKind.IsCopyOperation()); + if (copyOperation == null) { return; @@ -140,7 +145,7 @@ private void ComputeOperations(Operation copyOperation) var originalDto = copyOperation.OriginalThing; var originalPoco = originalDto.QuerySourceThing(); - + if (copyPoco.TopContainer.ClassKind != ClassKind.EngineeringModel) { throw new InvalidOperationException("The copy operation on WSP is only implemented for things contained by EngineeringModel."); @@ -154,6 +159,7 @@ private void ComputeOperations(Operation copyOperation) // Add all contained objects this.copyableIds.AddRange(copyPermissionResult.CopyableThings.Select(c => c.Iid).ToList()); + if (this.copyableIds.Contains(originalPoco.Iid)) { var updatedIteration = copyPoco.GetContainerOfType(); @@ -162,6 +168,7 @@ private void ComputeOperations(Operation copyOperation) // modify the references to point to the copy thing this.ModifyReferences(); + if (copyOperation.OperationKind.IsCopyChangeOwnerOperation()) { this.ChangeOwner(updatedIteration); @@ -207,6 +214,7 @@ private void CreatePocoCopy(Poco poco, Iteration targetIteration) foreach (var containerList in poco.ContainerLists) { var updatedContainerList = new List(); + foreach (Poco containedPoco in containerList) { if (!this.copyableIds.Contains(containedPoco.Iid)) @@ -265,6 +273,7 @@ private void CreateOperations() } #region Modify References + /// /// Modify the references for a and all its contained elements /// @@ -310,6 +319,7 @@ private void ModifyReferences(ElementUsage usage) private void ModifyReferences(Parameter parameter) { parameter.StateDependence = null; + if (parameter.Group == null) { return; @@ -318,6 +328,7 @@ private void ModifyReferences(Parameter parameter) // if the group cannot be copied, set to null Poco groupCopy; this.copyThingMap.TryGetValue(parameter.Group, out groupCopy); + parameter.Group = this.copyThingMap.TryGetValue(parameter.Group, out groupCopy) ? (ParameterGroup)groupCopy : null; @@ -337,6 +348,7 @@ private void ModifyReferences(ParameterGroup group) // if the group cannot be copied, set to null Poco groupCopy; this.copyThingMap.TryGetValue(group.ContainingGroup, out groupCopy); + group.ContainingGroup = this.copyThingMap.TryGetValue(group.ContainingGroup, out groupCopy) ? (ParameterGroup)groupCopy : null; @@ -352,6 +364,7 @@ private void ModifyReferences(ParameterOverride parameterOverride) var copy = (Parameter)this.copyThingMap[parameterOverride.Parameter]; parameterOverride.Parameter = copy; } + #endregion /// @@ -361,12 +374,14 @@ private void ModifyReferences(ParameterOverride parameterOverride) private void ChangeOwner(Iteration iteration) { var activeDomain = this.session.OpenIterations.Single(x => x.Key.Iid == iteration.Iid).Value.Item1; + if (activeDomain == null) { throw new InvalidOperationException("The active domain is null. The copy operation cannot be performed."); } var ownedThings = this.copyThingMap.Values.OfType().ToList(); + foreach (var ownedThing in ownedThings) { // the owner of a subscription shall not be set to the active one @@ -379,4 +394,4 @@ private void ChangeOwner(Iteration iteration) } } } -} \ No newline at end of file +} diff --git a/CDP4WspDal/OperationModifier.cs b/CDP4WspDal/OperationModifier.cs index 2e763ef7..52cea9c7 100644 --- a/CDP4WspDal/OperationModifier.cs +++ b/CDP4WspDal/OperationModifier.cs @@ -1,38 +1,42 @@ -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal { using System; using System.Collections.Generic; using System.Linq; + using CDP4Common.CommonData; - using CDP4Common.EngineeringModelData; + using CDP4Common.EngineeringModelData; using CDP4Common.Types; + using CDP4Dal; using CDP4Dal.Operations; + using CDP4DalCommon.Protocol.Operations; + using ActualFiniteState = CDP4Common.DTO.ActualFiniteState; using ElementUsage = CDP4Common.DTO.ElementUsage; using ParameterOverride = CDP4Common.DTO.ParameterOverride; @@ -72,6 +76,7 @@ public void ModifyOperationContainer(OperationContainer operationContainer) if (operation.OperationKind == OperationKind.Create) { var parameterOverride = operation.ModifiedThing as ParameterOverride; + if (parameterOverride != null) { operationsToAdd.AddRange(this.AddParameterSubscriptionCreateOperation(operationContainer, parameterOverride)); @@ -80,6 +85,7 @@ public void ModifyOperationContainer(OperationContainer operationContainer) else if (operation.OperationKind == OperationKind.Update) { var possibleStateList = operation.ModifiedThing as PossibleFiniteStateList; + if (possibleStateList != null) { operationsToAdd.AddRange(this.ModifyActualStateKindOnDefaultPossibleStateUpdate(possibleStateList)); @@ -90,7 +96,7 @@ public void ModifyOperationContainer(OperationContainer operationContainer) foreach (var operation in operationsToAdd) { operationContainer.AddOperation(operation); - } + } } /// @@ -104,12 +110,14 @@ private IEnumerable AddParameterSubscriptionCreateOperation(Operation var parameterId = parameterOverride.Parameter; Lazy lazyParameter; var operations = new List(); + if (!this.session.Assembler.Cache.TryGetValue(new CacheKey(parameterId, parameterOverride.IterationContainerId), out lazyParameter)) { return operations; } - + var parameter = (Parameter)lazyParameter.Value; + foreach (var subscription in parameter.ParameterSubscription.Where(x => x.Owner.Iid != parameterOverride.Owner)) { var parameterSubscription = new ParameterSubscription @@ -123,13 +131,14 @@ private IEnumerable AddParameterSubscriptionCreateOperation(Operation operationContainer.Operations.Select(x => x.ModifiedThing) .OfType() .SingleOrDefault(x => x.ParameterOverride.Contains(parameterOverride.Iid)); - + if (elementUsageContainer == null) { continue; } Lazy lazyElementUsageContainer; + if (!this.session.Assembler.Cache.TryGetValue(new CacheKey(elementUsageContainer.Iid, elementUsageContainer.IterationContainerId), out lazyElementUsageContainer)) { continue; @@ -166,6 +175,7 @@ private IEnumerable ModifyActualStateKindOnDefaultPossibleStateUpdate { var operations = new List(); var defaultStateId = possibleFiniteStateList.DefaultState; + if (!defaultStateId.HasValue) { return operations; @@ -173,14 +183,15 @@ private IEnumerable ModifyActualStateKindOnDefaultPossibleStateUpdate // gets the actualList that uses the updated possible list var actualLists = this.session.Assembler.Cache.Select(x => x.Value) - .Select(x => x.Value) - .OfType() - .Where(x => x.PossibleFiniteStateList.Select(pl => pl.Iid).Contains(possibleFiniteStateList.Iid)) - .ToList(); + .Select(x => x.Value) + .OfType() + .Where(x => x.PossibleFiniteStateList.Select(pl => pl.Iid).Contains(possibleFiniteStateList.Iid)) + .ToList(); foreach (var actualFiniteStateList in actualLists) { var possibleLists = actualFiniteStateList.PossibleFiniteStateList.Where(x => x.Iid != possibleFiniteStateList.Iid).ToList(); + if (possibleLists.Any(x => x.DefaultState == null)) { // one of the possible list has no default state @@ -212,4 +223,4 @@ private IEnumerable ModifyActualStateKindOnDefaultPossibleStateUpdate return operations; } } -} \ No newline at end of file +} diff --git a/CDP4WspDal/ValueSetOperationCreator.cs b/CDP4WspDal/ValueSetOperationCreator.cs index ee1c1545..9aa9f59d 100644 --- a/CDP4WspDal/ValueSetOperationCreator.cs +++ b/CDP4WspDal/ValueSetOperationCreator.cs @@ -1,38 +1,41 @@ -#region Copyright -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- -#endregion +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal { using System; using System.Collections.Generic; using System.Linq; + using CDP4Common.CommonData; - using CDP4Common.EngineeringModelData; + using CDP4Common.EngineeringModelData; + using CDP4Dal; using CDP4Dal.Operations; + + using CDP4DalCommon.Protocol.Operations; + using Dto = CDP4Common.DTO; /// @@ -44,7 +47,7 @@ internal class ValueSetOperationCreator /// The associated /// private readonly ISession session; - + /// /// Initializes a new instance of the class /// @@ -70,6 +73,7 @@ public OperationContainer CreateValueSetsUpdateOperations(string context, IEnume var dtolist = dtos.ToList(); var topContainer = dtolist.SingleOrDefault(x => x is Dto.TopContainer); + if (topContainer == null) { throw new InvalidOperationException("No Top container were found in the returned list of dtos."); @@ -78,9 +82,10 @@ public OperationContainer CreateValueSetsUpdateOperations(string context, IEnume // Gets the parameter base which value set shall be updated var copyParameterBases = dtolist.OfType().ToList(); var copyParameterBasesIds = copyParameterBases.Select(p => p.Iid).ToList(); - var valuesets = dtolist.Where(dto => dto.ClassKind == ClassKind.ParameterValueSet || - dto.ClassKind == ClassKind.ParameterSubscriptionValueSet || - dto.ClassKind == ClassKind.ParameterOverrideValueSet).ToList(); + + var valuesets = dtolist.Where(dto => dto.ClassKind == ClassKind.ParameterValueSet || + dto.ClassKind == ClassKind.ParameterSubscriptionValueSet || + dto.ClassKind == ClassKind.ParameterOverrideValueSet).ToList(); this.ComputeRoutes(valuesets, dtolist); var valueSetsClones = valuesets.Select(dto => dto.DeepClone()).ToList(); @@ -98,6 +103,7 @@ public OperationContainer CreateValueSetsUpdateOperations(string context, IEnume // value sets to update var copyValueSets = valueSetsClones.Where(x => copyDto.ValueSets.Contains(x.Iid)).ToList(); var defaultValueSet = this.GetDefaultValueSet(originalParameter); + if (defaultValueSet == null) { continue; @@ -105,8 +111,9 @@ public OperationContainer CreateValueSetsUpdateOperations(string context, IEnume this.SetValueSetValues(copyValueSets, defaultValueSet); } - + var operationContainer = new OperationContainer(context, topContainer.RevisionNumber); + foreach (var valueSetsClone in valueSetsClones) { var valuesetToUpdate = valuesets.Single(x => x.Iid == valueSetsClone.Iid); @@ -203,4 +210,4 @@ private void SetValueSetValues(Dto.ParameterSubscriptionValueSet valueSet, Param valueSet.ValueSwitch = originalValueSet.ValueSwitch; } } -} \ No newline at end of file +} diff --git a/CDP4WspDal/WSPDal.cs b/CDP4WspDal/WSPDal.cs index 2bdf168a..69c2a918 100644 --- a/CDP4WspDal/WSPDal.cs +++ b/CDP4WspDal/WSPDal.cs @@ -1,21 +1,21 @@ // ------------------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2021 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou, Alexandervan Delft, Nathanael Smiechowski, Ahmed Abulwafa Ahmed -// -// This file is part of COMET-SDK Community Edition -// -// The COMET-SDK Community Edition is free software; you can redistribute it and/or +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The COMET-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. @@ -27,7 +27,6 @@ namespace CDP4WspDal #if NETFRAMEWORK using System.ComponentModel.Composition; #endif - using System; using System.Collections.Generic; using System.Diagnostics; @@ -50,10 +49,11 @@ namespace CDP4WspDal using CDP4Dal.Exceptions; using CDP4Dal.Operations; - using CDP4DalCommon.Tasks; + using CDP4DalCommon.Protocol.Operations; + using CDP4DalCommon.Protocol.Tasks; + + using CDP4DalJsonSerializer; - using CDP4JsonSerializer; - using NLog; using EngineeringModelSetup = CDP4Common.SiteDirectoryData.EngineeringModelSetup; @@ -83,13 +83,13 @@ public class WspDal : Dal /// public WspDal() { - this.Serializer = new Cdp4JsonSerializer(this.MetaDataProvider, this.DalVersion); + this.Serializer = new Cdp4DalJsonSerializer(this.MetaDataProvider, this.DalVersion, true); } /// - /// Gets or sets the + /// Gets or sets the /// - public Cdp4JsonSerializer Serializer { get; private set; } + public Cdp4DalJsonSerializer Serializer { get; private set; } /// /// Gets the value indicating whether this is read only @@ -140,18 +140,19 @@ public override async Task> Write(OperationContainer operatio modifier.ModifyOperationContainer(operationContainer); var invalidOperationKind = operationContainer.Operations.Any(operation => operation.OperationKind == OperationKind.Move || OperationKindExtensions.IsCopyOperation(operation.OperationKind)); + if (invalidOperationKind) { throw new InvalidOperationKindException("The WSP DAL does not support Copy or Move operations"); } - + var result = new List(); if (files != null && files.Any()) { this.OperationContainerFileVerification(operationContainer, files); } - + var attribute = new QueryAttributes { RevisionNumber = operationContainer.TopContainerRevisionNumber @@ -180,12 +181,13 @@ public override async Task> Write(OperationContainer operatio Logger.Error(msg); throw new DalWriteException(msg); } - + using (var resultStream = await httpResponseMessage.Content.ReadAsStreamAsync()) { result.AddRange(this.Serializer.Deserialize(resultStream)); Guid iterationId; + if (this.TryExtractIterationIdfromUri(httpResponseMessage.RequestMessage.RequestUri, out iterationId)) { this.SetIterationContainer(result, iterationId); @@ -204,6 +206,7 @@ public override async Task> Write(OperationContainer operatio foreach (var valueSetDto in valueSetResult) { var index = result.FindIndex(x => x.Iid == valueSetDto.Iid); + if (index >= 0) { result[index] = valueSetDto; @@ -282,6 +285,7 @@ public override async Task> Read(CDP4Common.DTO.Iteration ite // Get the RequiredRdl to load var siteDirectory = this.Session.Assembler.RetrieveSiteDirectory(); var iterationSetup = siteDirectory.Model.SelectMany(mod => mod.IterationSetup).SingleOrDefault(it => it.IterationIid == iteration.Iid); + if (iterationSetup == null) { throw new InvalidOperationException("The Iteration to open does not have any associated IterationSetup."); @@ -401,12 +405,13 @@ public override async Task> Read(T thing, CancellationToke Logger.Error(msg); throw new DalReadException(msg); } - + using (var resultStream = await httpResponseMessage.Content.ReadAsStreamAsync()) { var returned = this.Serializer.Deserialize(resultStream); Guid iterationId; + if (this.TryExtractIterationIdfromUri(httpResponseMessage.RequestMessage.RequestUri, out iterationId)) { this.SetIterationContainer(returned, iterationId); @@ -419,7 +424,7 @@ public override async Task> Read(T thing, CancellationToke } } } - + /// /// Reads the identified by the provided /// @@ -529,9 +534,9 @@ public override async Task> Open(Credentials credentials, Can var openToken = CDP4Common.Helpers.TokenGenerator.GenerateRandomToken(); this.httpClient = this.CreateHttpClient(credentials); - + var watch = Stopwatch.StartNew(); - + var uriBuilder = this.GetUriBuilder(credentials.Uri, ref resourcePath); Logger.Debug("Resource Path {0}: {1}", openToken, resourcePath); @@ -543,7 +548,7 @@ public override async Task> Open(Credentials credentials, Can { Logger.Info("The ECSS-E-TM-10-25A Annex C Services responded in {0} [ms] to Open {1}", requestsw.ElapsedMilliseconds, openToken); requestsw.Stop(); - + if (httpResponseMessage.StatusCode != HttpStatusCode.OK) { var msg = $"The data-source replied with code {httpResponseMessage.StatusCode}: {httpResponseMessage.ReasonPhrase}"; @@ -553,7 +558,7 @@ public override async Task> Open(Credentials credentials, Can watch.Stop(); Logger.Info("WSP DAL Open {0} completed in {1} [ms]", openToken, watch.ElapsedMilliseconds); - + watch = Stopwatch.StartNew(); using (var resultStream = await httpResponseMessage.Content.ReadAsStreamAsync()) @@ -564,6 +569,7 @@ public override async Task> Open(Credentials credentials, Can Logger.Info("JSON Deserializer completed in {0} [ms]", watch.ElapsedMilliseconds); var returnedPerson = returned.OfType().SingleOrDefault(x => x.ShortName == credentials.UserName); + if (returnedPerson == null) { throw new InvalidOperationException("User not found."); @@ -709,6 +715,7 @@ internal void ConstructPostRequestBodyStream(string token, OperationContainer op { outputStream.CopyTo(memoryStream); memoryStream.Position = 0; + using (var streamReader = new StreamReader(memoryStream)) { var postBody = streamReader.ReadToEnd(); @@ -763,6 +770,7 @@ public override bool IsValidUri(string uri) try { var validUriAssertion = new Uri(uri); + if (!(validUriAssertion.Scheme == Uri.UriSchemeHttp || validUriAssertion.Scheme == Uri.UriSchemeHttps)) { return false; @@ -814,6 +822,6 @@ private IQueryAttributes GetIUriQueryAttribute(bool includeReferenceData = false Extent = ExtentQueryAttribute.deep, IncludeAllContainers = true }; - } + } } } diff --git a/CDP4WspDal/WSPPostOperation.cs b/CDP4WspDal/WSPPostOperation.cs index 91de411e..8888b2b2 100644 --- a/CDP4WspDal/WSPPostOperation.cs +++ b/CDP4WspDal/WSPPostOperation.cs @@ -1,28 +1,26 @@ -#region Copyright -// -------------------------------------------------------------------------------------------------------------------- -// -// Copyright (c) 2015-2019 Starion Group S.A. -// -// Author: Sam Gerené, Merlin Bieze, Alex Vorobiev, Naron Phou -// -// This file is part of CDP4-SDK Community Edition -// -// The CDP4-SDK Community Edition is free software; you can redistribute it and/or +// ------------------------------------------------------------------------------------------------------------------------------- +// +// Copyright (c) 2015-2024 RHEA System S.A. +// +// Authors: Sam Gerené, Alex Vorobiev, Alexander van Delft, Nathanael Smiechowski, Antoine Théate, Omar Elebiary, Jaime Bernar +// +// This file is part of CDP4-COMET SDK Community Edition +// +// The CDP4-COMET SDK Community Edition is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. -// -// The CDP4-SDK Community Edition is distributed in the hope that it will be useful, +// +// The CDP4-COMET SDK Community Edition is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// +// // You should have received a copy of the GNU Lesser General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// -------------------------------------------------------------------------------------------------------------------- -#endregion +// ------------------------------------------------------------------------------------------------------------------------------- namespace CDP4WspDal { @@ -30,15 +28,16 @@ namespace CDP4WspDal using System.Collections; using System.Collections.Generic; using System.Linq; + using CDP4Common; using CDP4Common.CommonData; using CDP4Common.Dto; using CDP4Common.MetaInfo; using CDP4Common.SiteDirectoryData; using CDP4Common.Types; - using CDP4Dal.Operations; - using Newtonsoft.Json; - using DomainOfExpertise = CDP4Common.DTO.DomainOfExpertise; + + using CDP4DalCommon.Protocol.Operations; + using Thing = CDP4Common.DTO.Thing; /// @@ -63,25 +62,21 @@ public WspPostOperation(IMetaDataProvider metaDataProvider) /// /// Gets or sets the collection of DTOs to delete. /// - [JsonProperty("_delete")] public override List Delete { get; set; } /// /// Gets or sets the collection of DTOs to create. /// - [JsonProperty("_create")] public override List Create { get; set; } /// /// Gets or sets the collection of DTOs to update. /// - [JsonProperty("_update")] public override List Update { get; set; } /// /// Gets or sets the collection of DTOs to copy. /// - [JsonIgnore] public override List Copy { get; set; } /// @@ -139,6 +134,7 @@ private void ResolveUpdate(Operation operation) foreach (var key in original.Keys) { var originalIenumerable = original[key] as IEnumerable; + if (originalIenumerable != null && originalIenumerable.GetType().IsGenericType) { var modifiedIenumerable = (IEnumerable)modifiedFull[key]; @@ -162,6 +158,7 @@ private void ResolveUpdate(Operation operation) List modifiedProperty; var genericTypeArgument = original[key].GetType().GenericTypeArguments[0]; + if (genericTypeArgument == typeof(Guid) || genericTypeArgument == typeof(ClassKind) || genericTypeArgument == typeof(VcardTelephoneNumberKind)) { originalProperty = originalIenumerable.Cast().ToList(); @@ -206,6 +203,7 @@ private void ResolveUpdate(Operation operation) } var possibleDeletions = originalProperty.Except(modifiedProperty).ToList(); + if (possibleDeletions.Count > 0) { // this part will be added to the delete @@ -236,7 +234,7 @@ private void ResolveUpdate(Operation operation) { if (original[key].Equals(modifiedFull[key])) { - modified.Remove(key); + modified.Remove(key); } } } @@ -260,6 +258,7 @@ private void ResolveUpdate(Operation operation) if (listsToAdd.Count > 0) { var updateDto = modified; + foreach (var kvp in listsToAdd) { updateDto.Add(kvp.Key, kvp.Value); @@ -271,6 +270,6 @@ private void ResolveUpdate(Operation operation) { this.Update.Add(modified); } - } + } } }