Reimplement license with protobuf

tiksn · tiksn · commit 817607ba1692 · 2025-06-23T22:16:49.000-05:00
diff --git a/TIKSN.Framework.Core.Tests/Licensing/TestEntitlementsConverter.cs b/TIKSN.Framework.Core.Tests/Licensing/TestEntitlementsConverter.cs
@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using System.Linq;
+using Google.Protobuf;
 using LanguageExt;
 using LanguageExt.Common;
 using TIKSN.Licensing;
@@ -61,7 +63,7 @@ public Validation<Error, TestLicenseEntitlements> Convert(
             }
             else
             {
-                result.Salt = entitlements.Salt.ToArray();
+                result.Salt = ByteString.CopyFrom([.. entitlements.Salt]);
             }
         }
 
@@ -104,7 +106,7 @@ public Validation<Error, TestEntitlements> Convert(
                 errors.Add(Error.New(314894957, "EmployeeId is invalid"));
             }
 
-            if (entitlementsData.Salt.Count == 0)
+            if (entitlementsData.Salt.Length == 0)
             {
                 errors.Add(Error.New(139152695, "Salt is missing"));
             }
diff --git a/TIKSN.Framework.Core/Licensing/ILicenseFactory.cs b/TIKSN.Framework.Core/Licensing/ILicenseFactory.cs
@@ -1,13 +1,11 @@
 using System.Security.Cryptography.X509Certificates;
+using Google.Protobuf;
 using LanguageExt;
 using LanguageExt.Common;
 
 namespace TIKSN.Licensing;
 
-#pragma warning disable S2326 // Unused type parameters should be removed
-
-public interface ILicenseFactory<TEntitlements, TEntitlementsData>
-#pragma warning restore S2326 // Unused type parameters should be removed
+public interface ILicenseFactory<TEntitlements, TEntitlementsData> where TEntitlementsData : IMessage<TEntitlementsData>
 {
     Validation<Error, License<TEntitlements>> Create(
         LicenseTerms terms,
diff --git a/TIKSN.Framework.Core/Licensing/LicenseFactory.cs b/TIKSN.Framework.Core/Licensing/LicenseFactory.cs
@@ -1,31 +1,25 @@
 using System.Security.Cryptography.X509Certificates;
+using Google.Protobuf;
 using LanguageExt;
 using LanguageExt.Common;
 using Microsoft.Extensions.DependencyInjection;
-using TIKSN.Serialization.Bond;
 using static LanguageExt.Prelude;
 
 namespace TIKSN.Licensing;
 
-public class LicenseFactory<TEntitlements, TEntitlementsData> : ILicenseFactory<TEntitlements, TEntitlementsData>
+public class LicenseFactory<TEntitlements, TEntitlementsData> : ILicenseFactory<TEntitlements, TEntitlementsData> where TEntitlementsData : IMessage<TEntitlementsData>
 {
-    private readonly CompactBinaryBondDeserializer deserializer;
     private readonly IEntitlementsConverter<TEntitlements, TEntitlementsData> entitlementsConverter;
     private readonly ILicenseDescriptor<TEntitlements> licenseDescriptor;
-    private readonly CompactBinaryBondSerializer serializer;
     private readonly IServiceProvider serviceProvider;
     private readonly TimeProvider timeProvider;
 
     public LicenseFactory(
-        CompactBinaryBondSerializer serializer,
-        CompactBinaryBondDeserializer deserializer,
         ILicenseDescriptor<TEntitlements> licenseDescriptor,
         IEntitlementsConverter<TEntitlements, TEntitlementsData> entitlementsConverter,
         TimeProvider timeProvider,
         IServiceProvider serviceProvider)
     {
-        this.serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
-        this.deserializer = deserializer ?? throw new ArgumentNullException(nameof(deserializer));
         this.licenseDescriptor = licenseDescriptor ?? throw new ArgumentNullException(nameof(licenseDescriptor));
         this.entitlementsConverter = entitlementsConverter ?? throw new ArgumentNullException(nameof(entitlementsConverter));
         this.timeProvider = timeProvider ?? throw new ArgumentNullException(nameof(timeProvider));
@@ -49,8 +43,7 @@ public Validation<Error, License<TEntitlements>> Create(
 
         _ = this.entitlementsConverter.Convert(entitlements)
             .Match(
-                succ => envelope.Message.Entitlements =
-                    new ArraySegment<byte>(this.serializer.Serialize(succ)),
+                succ => envelope.Message.Entitlements = succ.ToByteString(),
                 fail => errors.AddRange(fail));
 
         if (!privateCertificate.HasPrivateKey)
@@ -63,15 +56,15 @@ public Validation<Error, License<TEntitlements>> Create(
             return errors.ToSeq();
         }
 
-        var messageData = this.serializer.Serialize(envelope.Message);
+        var messageData = envelope.Message.ToByteString();
 
         var keyAlgorithm = privateCertificate.GetKeyAlgorithm();
         envelope.SignatureAlgorithm = keyAlgorithm;
         var signatureService = this.serviceProvider.GetRequiredKeyedService<ICertificateSignatureService>(keyAlgorithm);
-        var signature = signatureService.Sign(messageData, privateCertificate);
-        envelope.Signature = new ArraySegment<byte>(signature);
+        var signature = signatureService.Sign(messageData.ToByteArray(), privateCertificate);
+        envelope.Signature = ByteString.CopyFrom(signature);
 
-        var envelopeData = this.serializer.Serialize(envelope);
+        var envelopeData = envelope.ToByteString();
 
         return new License<TEntitlements>(
             terms,
@@ -93,10 +86,14 @@ public Validation<Error, License<TEntitlements>> Create(
             return errors.ToSeq();
         }
 
-        var envelope = this.deserializer.Deserialize<LicenseEnvelope>([.. data]);
+        var envelope = LicenseEnvelope.Parser.ParseFrom([.. data]);
 
         var licenseTermsValidation = this.GetTerms(envelope, this.timeProvider);
-        var entitlementsValidation = this.entitlementsConverter.Convert(this.deserializer.Deserialize<TEntitlementsData>([.. envelope.Message.Entitlements]));
+
+        var entitlementsData = Activator.CreateInstance<TEntitlementsData>();
+        entitlementsData.MergeFrom(envelope.Message.Entitlements.CreateCodedInput());
+
+        var entitlementsValidation = this.entitlementsConverter.Convert(entitlementsData);
 
         var keyAlgorithm = publicCertificate.GetKeyAlgorithm();
 
@@ -107,9 +104,9 @@ public Validation<Error, License<TEntitlements>> Create(
 
         var signatureService = this.serviceProvider.GetRequiredKeyedService<ICertificateSignatureService>(keyAlgorithm);
 
-        var messageData = this.serializer.Serialize(envelope.Message);
+        var messageData = envelope.Message.ToByteArray();
 
-        if (!signatureService.Verify(messageData, [.. envelope.Signature], publicCertificate))
+        if (!signatureService.Verify(messageData, envelope.Signature.ToByteArray(), publicCertificate))
         {
             errors.Add(Error.New(1311896038, "License signature is invalid"));
         }
@@ -133,12 +130,7 @@ private Validation<Error, LicenseTerms> GetTerms(
     {
         ArgumentNullException.ThrowIfNull(envelope);
 
-        if (envelope.Message.VersionNumber != 1)
-        {
-            return Error.New(2129266854, "License version is invalid");
-        }
-
-        if (envelope.Message.Discriminator.Count != Guid.Empty.ToByteArray().Length ||
+        if (envelope.Message.Discriminator.Count() != Guid.Empty.ToByteArray().Length ||
             envelope.Message.Discriminator.All(x => x == byte.MinValue) ||
             !envelope.Message.Discriminator.SequenceEqual(this.licenseDescriptor.Discriminator.ToByteArray()))
         {
@@ -193,14 +185,15 @@ private Validation<Error, LicenseEnvelope> Populate(
 
         var errors = new List<Error>();
 
-        envelope.Message.VersionNumber = 1;
-
         if (this.licenseDescriptor.Discriminator == Guid.Empty)
         {
             errors.Add(Error.New(13127674, "'Discriminator' should not be empty GUID"));
         }
 
-        envelope.Message.Discriminator = new ArraySegment<byte>(this.licenseDescriptor.Discriminator.ToByteArray());
+        envelope.Message = new LicenseMessage
+        {
+            Discriminator = ByteString.CopyFrom(this.licenseDescriptor.Discriminator.ToByteArray()),
+        };
 
         if (terms.NotAfter < terms.NotBefore)
         {
diff --git a/TIKSN.Framework.Core/Licensing/LicenseFactoryTermsValidation.cs b/TIKSN.Framework.Core/Licensing/LicenseFactoryTermsValidation.cs
@@ -1,8 +1,9 @@
 using System.Net.Mail;
-using Bond;
+using Google.Protobuf;
 using LanguageExt;
 using LanguageExt.Common;
 using static LanguageExt.Prelude;
+using static TIKSN.Licensing.LicenseParty;
 
 namespace TIKSN.Licensing;
 
@@ -40,19 +41,19 @@ internal static Validation<Error, DateTimeOffset> ConvertToDate(long dateTicks)
     private static readonly Seq<Ulid> InvalidSerialNumbers =
         Seq(Ulid.Empty, Ulid.MinValue, Ulid.MaxValue);
 
-    internal static Validation<Error, ArraySegment<byte>> ConvertFromUlid(Ulid serialNumber)
+    internal static Validation<Error, ByteString> ConvertFromUlid(Ulid serialNumber)
     {
         if (InvalidSerialNumbers.Contains(serialNumber))
         {
             return Error.New(877535586, "Invalid serial number");
         }
 
-        return new ArraySegment<byte>(serialNumber.ToByteArray());
+        return ByteString.CopyFrom(serialNumber.ToByteArray());
     }
 
-    internal static Validation<Error, Ulid> ConvertToUlid(ArraySegment<byte> serialNumberBytes)
+    internal static Validation<Error, Ulid> ConvertToUlid(ByteString serialNumberBytes)
     {
-        var serialNumber = new Ulid(serialNumberBytes);
+        var serialNumber = new Ulid(serialNumberBytes.ToByteArray());
 
         if (InvalidSerialNumbers.Contains(serialNumber))
         {
@@ -129,34 +130,31 @@ internal static Validation<Error, MailAddress> ConvertToMailAddress(string addre
 
     #region Party
 
-    internal static Validation<Error, IBonded<LicenseParty>> ConvertFromParty(Party party) => party switch
+    internal static Validation<Error, LicenseParty> ConvertFromParty(Party party) => party switch
     {
-        IndividualParty individualParty => ConvertFromIndividual(individualParty).Map<IBonded<LicenseParty>>(x => new Bonded<LicenseIndividualParty>(x)),
-        OrganizationParty organizationParty => ConvertFromOrganization(organizationParty).Map<IBonded<LicenseParty>>(x => new Bonded<LicenseOrganizationParty>(x)),
+        IndividualParty individualParty => ConvertFromIndividual(individualParty),
+        OrganizationParty organizationParty => ConvertFromOrganization(organizationParty),
         _ => Error.New(2143629281, "Invalid party type"),
     };
 
-    internal static Validation<Error, Party> ConvertToParty(IBonded<LicenseParty> licenseParty)
-    {
-        var licensePartyBase = licenseParty.Deserialize();
-        return licensePartyBase.Kind switch
+    internal static Validation<Error, Party> ConvertToParty(LicenseParty licenseParty) =>
+        licenseParty.PartyKindCase switch
         {
-            LicensePartyKind.Unknown => Error.New(2084794372, "Unknown party type"),
-            LicensePartyKind.Individual => ConvertToIndividual(licenseParty.Deserialize<LicenseIndividualParty>()).Map<Party>(x => x),
-            LicensePartyKind.Organization => ConvertToOrganization(licenseParty.Deserialize<LicenseOrganizationParty>()).Map<Party>(x => x),
+            PartyKindOneofCase.None => Error.New(2084794372, "Unknown or No party type"),
+            PartyKindOneofCase.IndividualParty => ConvertToIndividual(licenseParty).Map<Party>(x => x),
+            PartyKindOneofCase.OrganizationParty => ConvertToOrganization(licenseParty).Map<Party>(x => x),
             _ => Error.New(103216125, "Invalid party type"),
         };
-    }
 
-    private static Validation<Error, LicenseIndividualParty> ConvertFromIndividual(
+    private static Validation<Error, LicenseParty> ConvertFromIndividual(
         IndividualParty individualParty)
     {
         ArgumentNullException.ThrowIfNull(individualParty);
 
         var errors = new List<Error>();
-        var result = new LicenseIndividualParty
+        var result = new LicenseParty
         {
-            Kind = LicensePartyKind.Individual,
+            IndividualParty = new LicenseIndividualParty()
         };
 
         if (string.IsNullOrWhiteSpace(individualParty.FirstName))
@@ -165,7 +163,7 @@ private static Validation<Error, LicenseIndividualParty> ConvertFromIndividual(
         }
         else
         {
-            result.FirstName = individualParty.FirstName;
+            result.IndividualParty.FirstName = individualParty.FirstName;
         }
 
         if (string.IsNullOrWhiteSpace(individualParty.LastName))
@@ -174,16 +172,16 @@ private static Validation<Error, LicenseIndividualParty> ConvertFromIndividual(
         }
         else
         {
-            result.LastName = individualParty.LastName;
+            result.IndividualParty.LastName = individualParty.LastName;
         }
 
         if (string.IsNullOrWhiteSpace(individualParty.FullName))
         {
-            result.FullName = $"{individualParty.FirstName} {individualParty.LastName}";
+            result.IndividualParty.FullName = $"{individualParty.FirstName} {individualParty.LastName}";
         }
         else
         {
-            result.FullName = individualParty.FullName;
+            result.IndividualParty.FullName = individualParty.FullName;
         }
 
         SetBasePartyProperties(individualParty, errors, result);
@@ -196,15 +194,15 @@ private static Validation<Error, LicenseIndividualParty> ConvertFromIndividual(
         return result;
     }
 
-    private static Validation<Error, LicenseOrganizationParty> ConvertFromOrganization(
+    private static Validation<Error, LicenseParty> ConvertFromOrganization(
         OrganizationParty organizationParty)
     {
         ArgumentNullException.ThrowIfNull(organizationParty);
 
         var errors = new List<Error>();
-        var result = new LicenseOrganizationParty
+        var result = new LicenseParty
         {
-            Kind = LicensePartyKind.Organization,
+            OrganizationParty = new LicenseOrganizationParty()
         };
 
         if (string.IsNullOrWhiteSpace(organizationParty.LongName))
@@ -213,7 +211,7 @@ private static Validation<Error, LicenseOrganizationParty> ConvertFromOrganizati
         }
         else
         {
-            result.LongName = organizationParty.LongName;
+            result.OrganizationParty.LongName = organizationParty.LongName;
         }
 
         if (string.IsNullOrWhiteSpace(organizationParty.ShortName))
@@ -222,7 +220,7 @@ private static Validation<Error, LicenseOrganizationParty> ConvertFromOrganizati
         }
         else
         {
-            result.ShortName = organizationParty.ShortName;
+            result.OrganizationParty.ShortName = organizationParty.ShortName;
         }
 
         SetBasePartyProperties(organizationParty, errors, result);
@@ -236,27 +234,27 @@ private static Validation<Error, LicenseOrganizationParty> ConvertFromOrganizati
     }
 
     private static Validation<Error, IndividualParty> ConvertToIndividual(
-        LicenseIndividualParty licenseIndividualParty)
+        LicenseParty licenseParty)
     {
-        ArgumentNullException.ThrowIfNull(licenseIndividualParty);
+        ArgumentNullException.ThrowIfNull(licenseParty);
 
         var errors = new List<Error>();
 
-        if (string.IsNullOrWhiteSpace(licenseIndividualParty.FirstName))
+        if (string.IsNullOrWhiteSpace(licenseParty.IndividualParty.FirstName))
         {
             errors.Add(Error.New(1348133387, "First Name is missing"));
         }
 
-        if (string.IsNullOrWhiteSpace(licenseIndividualParty.LastName))
+        if (string.IsNullOrWhiteSpace(licenseParty.IndividualParty.LastName))
         {
             errors.Add(Error.New(946047972, "Last Name is missing"));
         }
 
-        var fullName = string.IsNullOrWhiteSpace(licenseIndividualParty.FullName)
-            ? $"{licenseIndividualParty.FirstName} {licenseIndividualParty.LastName}"
-            : licenseIndividualParty.FullName;
+        var fullName = string.IsNullOrWhiteSpace(licenseParty.IndividualParty.FullName)
+            ? $"{licenseParty.IndividualParty.FirstName} {licenseParty.IndividualParty.LastName}"
+            : licenseParty.IndividualParty.FullName;
 
-        var basePartyProperties = GetBasePartyProperties(licenseIndividualParty);
+        var basePartyProperties = GetBasePartyProperties(licenseParty);
 
         if (errors.Count != 0)
         {
@@ -265,31 +263,31 @@ private static Validation<Error, IndividualParty> ConvertToIndividual(
 
         return basePartyProperties
             .Map(x => new IndividualParty(
-            licenseIndividualParty.FirstName,
-            licenseIndividualParty.LastName,
+            licenseParty.IndividualParty.FirstName,
+            licenseParty.IndividualParty.LastName,
             fullName,
             x.email,
             x.website));
     }
 
     private static Validation<Error, OrganizationParty> ConvertToOrganization(
-        LicenseOrganizationParty licenseOrganizationParty)
+        LicenseParty licenseParty)
     {
-        ArgumentNullException.ThrowIfNull(licenseOrganizationParty);
+        ArgumentNullException.ThrowIfNull(licenseParty);
 
         var errors = new List<Error>();
 
-        if (string.IsNullOrWhiteSpace(licenseOrganizationParty.LongName))
+        if (string.IsNullOrWhiteSpace(licenseParty.OrganizationParty.LongName))
         {
             errors.Add(Error.New(1625517012, "Long Name is missing"));
         }
 
-        if (string.IsNullOrWhiteSpace(licenseOrganizationParty.ShortName))
+        if (string.IsNullOrWhiteSpace(licenseParty.OrganizationParty.ShortName))
         {
             errors.Add(Error.New(280436811, "Short Name is missing"));
         }
 
-        var basePartyProperties = GetBasePartyProperties(licenseOrganizationParty);
+        var basePartyProperties = GetBasePartyProperties(licenseParty);
 
         if (errors.Count != 0)
         {
@@ -298,8 +296,8 @@ private static Validation<Error, OrganizationParty> ConvertToOrganization(
 
         return basePartyProperties
             .Map(x => new OrganizationParty(
-            licenseOrganizationParty.LongName,
-            licenseOrganizationParty.ShortName,
+            licenseParty.OrganizationParty.LongName,
+            licenseParty.OrganizationParty.ShortName,
             x.email,
             x.website));
     }
diff --git a/TIKSN.Framework.Core/Licensing/schema.proto b/TIKSN.Framework.Core/Licensing/schema.proto

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,6 @@`
`1`	`1`	`using System.Collections.Generic;`
	`2`	`+using System.Linq;`
	`3`	`+using Google.Protobuf;`
`2`	`4`	`using LanguageExt;`
`3`	`5`	`using LanguageExt.Common;`
`4`	`6`	`using TIKSN.Licensing;`
`@@ -61,7 +63,7 @@ public Validation<Error, TestLicenseEntitlements> Convert(`
`61`	`63`	`}`
`62`	`64`	`else`
`63`	`65`	`{`
`64`		`- result.Salt = entitlements.Salt.ToArray();`
	`66`	`+ result.Salt = ByteString.CopyFrom([.. entitlements.Salt]);`
`65`	`67`	`}`
`66`	`68`	`}`
`67`	`69`
`@@ -104,7 +106,7 @@ public Validation<Error, TestEntitlements> Convert(`
`104`	`106`	`errors.Add(Error.New(314894957, "EmployeeId is invalid"));`
`105`	`107`	`}`
`106`	`108`
`107`		`- if (entitlementsData.Salt.Count == 0)`
	`109`	`+ if (entitlementsData.Salt.Length == 0)`
`108`	`110`	`{`
`109`	`111`	`errors.Add(Error.New(139152695, "Salt is missing"));`
`110`	`112`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,9 @@`
`1`	`1`	`using System.Net.Mail;`
`2`		`-using Bond;`
	`2`	`+using Google.Protobuf;`
`3`	`3`	`using LanguageExt;`
`4`	`4`	`using LanguageExt.Common;`
`5`	`5`	`using static LanguageExt.Prelude;`
	`6`	`+using static TIKSN.Licensing.LicenseParty;`
`6`	`7`
`7`	`8`	`namespace TIKSN.Licensing;`
`8`	`9`
`@@ -40,19 +41,19 @@ internal static Validation<Error, DateTimeOffset> ConvertToDate(long dateTicks)`
`40`	`41`	`private static readonly Seq<Ulid> InvalidSerialNumbers =`
`41`	`42`	`Seq(Ulid.Empty, Ulid.MinValue, Ulid.MaxValue);`
`42`	`43`
`43`		`- internal static Validation<Error, ArraySegment<byte>> ConvertFromUlid(Ulid serialNumber)`
	`44`	`+ internal static Validation<Error, ByteString> ConvertFromUlid(Ulid serialNumber)`
`44`	`45`	`{`
`45`	`46`	`if (InvalidSerialNumbers.Contains(serialNumber))`
`46`	`47`	`{`
`47`	`48`	`return Error.New(877535586, "Invalid serial number");`
`48`	`49`	`}`
`49`	`50`
`50`		`- return new ArraySegment<byte>(serialNumber.ToByteArray());`
	`51`	`+ return ByteString.CopyFrom(serialNumber.ToByteArray());`
`51`	`52`	`}`
`52`	`53`
`53`		`- internal static Validation<Error, Ulid> ConvertToUlid(ArraySegment<byte> serialNumberBytes)`
	`54`	`+ internal static Validation<Error, Ulid> ConvertToUlid(ByteString serialNumberBytes)`
`54`	`55`	`{`
`55`		`- var serialNumber = new Ulid(serialNumberBytes);`
	`56`	`+ var serialNumber = new Ulid(serialNumberBytes.ToByteArray());`
`56`	`57`
`57`	`58`	`if (InvalidSerialNumbers.Contains(serialNumber))`
`58`	`59`	`{`
`@@ -129,34 +130,31 @@ internal static Validation<Error, MailAddress> ConvertToMailAddress(string addre`
`129`	`130`
`130`	`131`	`#region Party`
`131`	`132`
`132`		`- internal static Validation<Error, IBonded<LicenseParty>> ConvertFromParty(Party party) => party switch`
	`133`	`+ internal static Validation<Error, LicenseParty> ConvertFromParty(Party party) => party switch`
`133`	`134`	`{`
`134`		`- IndividualParty individualParty => ConvertFromIndividual(individualParty).Map<IBonded<LicenseParty>>(x => new Bonded<LicenseIndividualParty>(x)),`
`135`		`- OrganizationParty organizationParty => ConvertFromOrganization(organizationParty).Map<IBonded<LicenseParty>>(x => new Bonded<LicenseOrganizationParty>(x)),`
	`135`	`+ IndividualParty individualParty => ConvertFromIndividual(individualParty),`
	`136`	`+ OrganizationParty organizationParty => ConvertFromOrganization(organizationParty),`
`136`	`137`	`_ => Error.New(2143629281, "Invalid party type"),`
`137`	`138`	`};`
`138`	`139`
`139`		`- internal static Validation<Error, Party> ConvertToParty(IBonded<LicenseParty> licenseParty)`
`140`		`- {`
`141`		`- var licensePartyBase = licenseParty.Deserialize();`
`142`		`- return licensePartyBase.Kind switch`
	`140`	`+ internal static Validation<Error, Party> ConvertToParty(LicenseParty licenseParty) =>`
	`141`	`+ licenseParty.PartyKindCase switch`
`143`	`142`	`{`
`144`		`- LicensePartyKind.Unknown => Error.New(2084794372, "Unknown party type"),`
`145`		`- LicensePartyKind.Individual => ConvertToIndividual(licenseParty.Deserialize<LicenseIndividualParty>()).Map<Party>(x => x),`
`146`		`- LicensePartyKind.Organization => ConvertToOrganization(licenseParty.Deserialize<LicenseOrganizationParty>()).Map<Party>(x => x),`
	`143`	`+ PartyKindOneofCase.None => Error.New(2084794372, "Unknown or No party type"),`
	`144`	`+ PartyKindOneofCase.IndividualParty => ConvertToIndividual(licenseParty).Map<Party>(x => x),`
	`145`	`+ PartyKindOneofCase.OrganizationParty => ConvertToOrganization(licenseParty).Map<Party>(x => x),`
`147`	`146`	`_ => Error.New(103216125, "Invalid party type"),`
`148`	`147`	`};`
`149`		`- }`
`150`	`148`
`151`		`- private static Validation<Error, LicenseIndividualParty> ConvertFromIndividual(`
	`149`	`+ private static Validation<Error, LicenseParty> ConvertFromIndividual(`
`152`	`150`	`IndividualParty individualParty)`
`153`	`151`	`{`
`154`	`152`	`ArgumentNullException.ThrowIfNull(individualParty);`
`155`	`153`
`156`	`154`	`var errors = new List<Error>();`
`157`		`- var result = new LicenseIndividualParty`
	`155`	`+ var result = new LicenseParty`
`158`	`156`	`{`
`159`		`- Kind = LicensePartyKind.Individual,`
	`157`	`+ IndividualParty = new LicenseIndividualParty()`
`160`	`158`	`};`
`161`	`159`
`162`	`160`	`if (string.IsNullOrWhiteSpace(individualParty.FirstName))`
`@@ -165,7 +163,7 @@ private static Validation<Error, LicenseIndividualParty> ConvertFromIndividual(`
`165`	`163`	`}`
`166`	`164`	`else`
`167`	`165`	`{`
`168`		`- result.FirstName = individualParty.FirstName;`
	`166`	`+ result.IndividualParty.FirstName = individualParty.FirstName;`
`169`	`167`	`}`
`170`	`168`
`171`	`169`	`if (string.IsNullOrWhiteSpace(individualParty.LastName))`
`@@ -174,16 +172,16 @@ private static Validation<Error, LicenseIndividualParty> ConvertFromIndividual(`
`174`	`172`	`}`
`175`	`173`	`else`
`176`	`174`	`{`
`177`		`- result.LastName = individualParty.LastName;`
	`175`	`+ result.IndividualParty.LastName = individualParty.LastName;`
`178`	`176`	`}`
`179`	`177`
`180`	`178`	`if (string.IsNullOrWhiteSpace(individualParty.FullName))`
`181`	`179`	`{`
`182`		`- result.FullName = $"{individualParty.FirstName} {individualParty.LastName}";`
	`180`	`+ result.IndividualParty.FullName = $"{individualParty.FirstName} {individualParty.LastName}";`
`183`	`181`	`}`
`184`	`182`	`else`
`185`	`183`	`{`
`186`		`- result.FullName = individualParty.FullName;`
	`184`	`+ result.IndividualParty.FullName = individualParty.FullName;`
`187`	`185`	`}`
`188`	`186`
`189`	`187`	`SetBasePartyProperties(individualParty, errors, result);`
`@@ -196,15 +194,15 @@ private static Validation<Error, LicenseIndividualParty> ConvertFromIndividual(`
`196`	`194`	`return result;`
`197`	`195`	`}`
`198`	`196`
`199`		`- private static Validation<Error, LicenseOrganizationParty> ConvertFromOrganization(`
	`197`	`+ private static Validation<Error, LicenseParty> ConvertFromOrganization(`
`200`	`198`	`OrganizationParty organizationParty)`
`201`	`199`	`{`
`202`	`200`	`ArgumentNullException.ThrowIfNull(organizationParty);`
`203`	`201`
`204`	`202`	`var errors = new List<Error>();`
`205`		`- var result = new LicenseOrganizationParty`
	`203`	`+ var result = new LicenseParty`
`206`	`204`	`{`
`207`		`- Kind = LicensePartyKind.Organization,`
	`205`	`+ OrganizationParty = new LicenseOrganizationParty()`
`208`	`206`	`};`
`209`	`207`
`210`	`208`	`if (string.IsNullOrWhiteSpace(organizationParty.LongName))`
`@@ -213,7 +211,7 @@ private static Validation<Error, LicenseOrganizationParty> ConvertFromOrganizati`
`213`	`211`	`}`
`214`	`212`	`else`
`215`	`213`	`{`
`216`		`- result.LongName = organizationParty.LongName;`
	`214`	`+ result.OrganizationParty.LongName = organizationParty.LongName;`
`217`	`215`	`}`
`218`	`216`
`219`	`217`	`if (string.IsNullOrWhiteSpace(organizationParty.ShortName))`
`@@ -222,7 +220,7 @@ private static Validation<Error, LicenseOrganizationParty> ConvertFromOrganizati`
`222`	`220`	`}`
`223`	`221`	`else`
`224`	`222`	`{`
`225`		`- result.ShortName = organizationParty.ShortName;`
	`223`	`+ result.OrganizationParty.ShortName = organizationParty.ShortName;`
`226`	`224`	`}`
`227`	`225`
`228`	`226`	`SetBasePartyProperties(organizationParty, errors, result);`
`@@ -236,27 +234,27 @@ private static Validation<Error, LicenseOrganizationParty> ConvertFromOrganizati`
`236`	`234`	`}`
`237`	`235`
`238`	`236`	`private static Validation<Error, IndividualParty> ConvertToIndividual(`
`239`		`- LicenseIndividualParty licenseIndividualParty)`
	`237`	`+ LicenseParty licenseParty)`
`240`	`238`	`{`
`241`		`- ArgumentNullException.ThrowIfNull(licenseIndividualParty);`
	`239`	`+ ArgumentNullException.ThrowIfNull(licenseParty);`
`242`	`240`
`243`	`241`	`var errors = new List<Error>();`
`244`	`242`
`245`		`- if (string.IsNullOrWhiteSpace(licenseIndividualParty.FirstName))`
	`243`	`+ if (string.IsNullOrWhiteSpace(licenseParty.IndividualParty.FirstName))`
`246`	`244`	`{`
`247`	`245`	`errors.Add(Error.New(1348133387, "First Name is missing"));`
`248`	`246`	`}`
`249`	`247`
`250`		`- if (string.IsNullOrWhiteSpace(licenseIndividualParty.LastName))`
	`248`	`+ if (string.IsNullOrWhiteSpace(licenseParty.IndividualParty.LastName))`
`251`	`249`	`{`
`252`	`250`	`errors.Add(Error.New(946047972, "Last Name is missing"));`
`253`	`251`	`}`
`254`	`252`
`255`		`- var fullName = string.IsNullOrWhiteSpace(licenseIndividualParty.FullName)`
`256`		`- ? $"{licenseIndividualParty.FirstName} {licenseIndividualParty.LastName}"`
`257`		`- : licenseIndividualParty.FullName;`
	`253`	`+ var fullName = string.IsNullOrWhiteSpace(licenseParty.IndividualParty.FullName)`
	`254`	`+ ? $"{licenseParty.IndividualParty.FirstName} {licenseParty.IndividualParty.LastName}"`
	`255`	`+ : licenseParty.IndividualParty.FullName;`
`258`	`256`
`259`		`- var basePartyProperties = GetBasePartyProperties(licenseIndividualParty);`
	`257`	`+ var basePartyProperties = GetBasePartyProperties(licenseParty);`
`260`	`258`
`261`	`259`	`if (errors.Count != 0)`
`262`	`260`	`{`
`@@ -265,31 +263,31 @@ private static Validation<Error, IndividualParty> ConvertToIndividual(`
`265`	`263`
`266`	`264`	`return basePartyProperties`
`267`	`265`	`.Map(x => new IndividualParty(`
`268`		`- licenseIndividualParty.FirstName,`
`269`		`- licenseIndividualParty.LastName,`
	`266`	`+ licenseParty.IndividualParty.FirstName,`
	`267`	`+ licenseParty.IndividualParty.LastName,`
`270`	`268`	`fullName,`
`271`	`269`	`x.email,`
`272`	`270`	`x.website));`
`273`	`271`	`}`
`274`	`272`
`275`	`273`	`private static Validation<Error, OrganizationParty> ConvertToOrganization(`
`276`		`- LicenseOrganizationParty licenseOrganizationParty)`
	`274`	`+ LicenseParty licenseParty)`
`277`	`275`	`{`
`278`		`- ArgumentNullException.ThrowIfNull(licenseOrganizationParty);`
	`276`	`+ ArgumentNullException.ThrowIfNull(licenseParty);`
`279`	`277`
`280`	`278`	`var errors = new List<Error>();`
`281`	`279`
`282`		`- if (string.IsNullOrWhiteSpace(licenseOrganizationParty.LongName))`
	`280`	`+ if (string.IsNullOrWhiteSpace(licenseParty.OrganizationParty.LongName))`
`283`	`281`	`{`
`284`	`282`	`errors.Add(Error.New(1625517012, "Long Name is missing"));`
`285`	`283`	`}`
`286`	`284`
`287`		`- if (string.IsNullOrWhiteSpace(licenseOrganizationParty.ShortName))`
	`285`	`+ if (string.IsNullOrWhiteSpace(licenseParty.OrganizationParty.ShortName))`
`288`	`286`	`{`
`289`	`287`	`errors.Add(Error.New(280436811, "Short Name is missing"));`
`290`	`288`	`}`
`291`	`289`
`292`		`- var basePartyProperties = GetBasePartyProperties(licenseOrganizationParty);`
	`290`	`+ var basePartyProperties = GetBasePartyProperties(licenseParty);`
`293`	`291`
`294`	`292`	`if (errors.Count != 0)`
`295`	`293`	`{`
`@@ -298,8 +296,8 @@ private static Validation<Error, OrganizationParty> ConvertToOrganization(`
`298`	`296`
`299`	`297`	`return basePartyProperties`
`300`	`298`	`.Map(x => new OrganizationParty(`
`301`		`- licenseOrganizationParty.LongName,`
`302`		`- licenseOrganizationParty.ShortName,`
	`299`	`+ licenseParty.OrganizationParty.LongName,`
	`300`	`+ licenseParty.OrganizationParty.ShortName,`
`303`	`301`	`x.email,`
`304`	`302`	`x.website));`
`305`	`303`	`}`