How to develop Link 3 artifacts

public class HTTPStepConfig : LinkConfigBase
{
      [LinkRequired]
      [LinkDefaultValue(nameof(RestCommands.POST))]
      [LinkDisplay(Name = "REST Command", Description = "", GroupName = "HTTP Settings", Order = 10)]
      public RestCommands RestCommand { get; set; }

      [LinkRequired]
      [LinkDisplay(Name = "Endpoint URL", Description = "", GroupName = "HTTP Settings", Order = 11)]
      public string EndpointUrl { get; set; }

      [LinkDisplay(Name = "Header: Content-Type", Description = "", GroupName = "HTTP Settings", Order = 12)]
      public string ContentType { get; set; }

      [LinkDisplay(Name = "Header: Accept", Description = "", GroupName = "HTTP Settings", Order = 13)]
      public string Accept { get; set; }

      [LinkRequired]
      [LinkDisplay(Name = "Connection Timeout", Description = "", GroupName = "HTTP Settings", Order = 14)]
      [LinkDefaultValue("30")]
      public int? Timeout { get; set; }

      [LinkRequired]
      [LinkDefaultValue(nameof(AuthenticationType.Basic))]
      [LinkDisplay(Name = "Authentication Type", Description = "", GroupName = "HTTP Settings - Authentication", Order = 20)]
      public AuthenticationType AuthenticationTypes { get; set; }

      [LinkRequired]
      [LinkDisplay(Name = "Username", Description = "", GroupName = "HTTP Settings - Authentication", Order = 21)]
      [LinkDependsOn(nameof(AuthenticationTypes), nameof(AuthenticationType.Basic))]
      public string BasicUsername { get; set; }

      [LinkRequired]
      [LinkPassword]
      [LinkDisplay(Name = "Password", Description = "", GroupName = "HTTP Settings - Authentication", Order = 22)]
      [LinkDependsOn(nameof(AuthenticationTypes), nameof(AuthenticationType.Basic))]
      public string BasicPassword { get; set; }

      [LinkRequired]
      [LinkDisplay(Name = "Api Key", Description = "", GroupName = "HTTP Settings - Authentication", Order = 25)]
      [LinkDependsOn(nameof(AuthenticationTypes), nameof(AuthenticationType.ApiKey))]
      public string ApiKeyName { get; set; }

      [LinkRequired]
      [LinkDisplay(Name = "Api Key Value", Description = "", GroupName = "HTTP Settings - Authentication", Order = 26)]
      [LinkDependsOn(nameof(AuthenticationTypes), nameof(AuthenticationType.ApiKey))]
      public string ApiKeyValue { get; set; }

      [LinkDisplay(Name = "Api Key in URL", Description = "If checked the Api Key will be in the URI instead of the headers", GroupName = "HTTP Settings - Authentication", Order = 27)]
      [LinkDependsOn(nameof(AuthenticationTypes), nameof(AuthenticationType.ApiKey))]
      public bool ApiSetKeyInUri { get; set; }
}

using Bizbrains.Link.Base;
using Bizbrains.Link.Base.ConfigAttributes;
using Bizbrains.Link.Services.Transaction.Tracking;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace Link.Examples.Retrieve
{
    public class MyRetrieveStepFactory : LinkStepFactoryBase<ILinkTransportRetrieve>
    {
        public override string StepDisplayName => "My http retrieve";

        public override string StepDescription => "Retrieves a payload from the configured Url.";

        public override void ConfigureServices(IServiceCollection serviceCollection)
        {
            serviceCollection.AddTransient<MyRetrieveStep>();
        }

        public override ILinkTransportRetrieve Create(IServiceProvider serviceProvider)
        {
            return serviceProvider.GetRequiredService<MyRetrieveStep>();
        }
    }

    public class MyRetrieveStep : TransportRetrieveBase<MyRetrieveStepConfig>
    {
        private readonly ILogger<MyRetrieveStep> logger;
        private readonly ILinkMessageFactory linkMessageFactory;

        public MyRetrieveStep(ILogger<MyRetrieveStep> logger, ILinkMessageFactory linkMessageFactory)
        {
            this.logger = logger;
            this.linkMessageFactory = linkMessageFactory;
        }

        public override string StepKeyName => "bizbrains-transport-retrieve-myretrieve";

        protected override string GenerateDisplayAddress(MyRetrieveStepConfig config)
        {
            return "MyRetriever";
        }

        protected override async Task Retrieve(ILinkRetrieveProvider retrieveProvider, MyRetrieveStepConfig config, CancellationToken ct)
        {
            var httpClient = new HttpClient();
            var httpRequest = new HttpRequestMessage(HttpMethod.Get, config.Url);

            logger.LogInformation($"Calling {config.Url}");
            var response = await httpClient.SendAsync(httpRequest, ct);
            logger.LogInformation("Http call done - reading response...");

            var body = await response.Content.ReadAsStreamAsync();

            logger.LogInformation($"Response read. Length: {body.Length}. Creating LinkMessage...");
            var linkMessage = await linkMessageFactory.CreateMessage(body);

            logger.LogInformation("LinkMessage created. Save the message in Inbox");
            await retrieveProvider.SaveToInbox(linkMessage, new LinkRetrieveAdditionalInfo { FileName = "MyHttpResponse.txt" });
        }
    }

    public class MyRetrieveStepConfig : ILinkConfig
    {
        [LinkRequired]
        [LinkDisplay(Name = "Url", GroupName = "Http", Order = 1)]
        public string Url { get; set; }
    }
}

using Bizbrains.Link.Base;
using Bizbrains.Link.Services.Transaction.Tracking;
using Microsoft.Extensions.DependencyInjection;

namespace Bizbrains.Link.Initialize.InitializeSteps.Xml
{
    public class XmlDisassemblerFactory : LinkStepFactoryBase<ILinkInitializeStep>
    {
        public override string StepDisplayName => "Custom InitStep Xml Disassembler";

        public override string StepDescription => "Custom Xml disassembler";

        public override void ConfigureServices(IServiceCollection serviceCollection)
        {
            serviceCollection.AddTransient<XmlDisassembler>();
            base.ConfigureServices(serviceCollection);
        }

        public override ILinkInitializeStep Create(IServiceProvider serviceProvider)
        {
            return serviceProvider.GetRequiredService<XmlDisassembler>();
        }
    }

    public class XmlDisassembler : InitializeStepBase<XmlDisassemblerConfig>
    {
        private readonly ILinkMessageFactory linkMessageFactory;

        public override string StepKeyName => "Custom-initialize-xml";

        public XmlDisassembler(ILinkMessageFactory linkMessageFactory)
        {
            this.linkMessageFactory = linkMessageFactory;
        }

        public override async Task<IEnumerable<ILinkMessage>> Process(ILinkMessage message, XmlDisassemblerConfig config, CancellationToken cancellationToken)
        {
            return new List<ILinkMessage>() { await linkMessageFactory.CreateXmlMessage(message.Body.Data, message.Properties) };
        }
    }
}

using Bizbrains.Link.Base;
using Bizbrains.Link.Base.ConfigAttributes;
using Bizbrains.Link.Base.Exceptions;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System.Xml.Linq;
using System.Xml.XPath;

namespace Link.Examples.ItineraryStep
{
    public class MyItineraryStepFactory : LinkStepFactoryBase<ILinkItineraryStep2>
    {
        public override string StepDisplayName => "My itinerary step";
        public override string StepDescription => "This step extracts a value from an XPath and promotes the value to context-properties.";
        public override void ConfigureServices(IServiceCollection serviceCollection)
        {
            // We add our step to the service-collection, because dependency injection will then resolve any services, repositories, logging and other stuff we expect in our constructor
            serviceCollection.AddTransient<MyItineraryStep>();
            // Add additional services, if you have any...
        }

        public const string ErrorCodeXPath = "AHREU"; // Generate the error-code in the Link UI (Developer -> Error codes -> Generate code)
        public const string ErrorCodeUnexpectedError = "01W7K";
        public override IEnumerable<LinkErrorCode> RegisterErrorCodes()
        {
            var errorCodes = new List<LinkErrorCode>();
            errorCodes.Add(new LinkErrorCode(ErrorCodeXPath, LinkExceptionTypeArea.Itinerary, LinkExceptionCategory.MissingConfigurationError, "MyItinerary", "XPath doesnt' return any element.", "Contact developer"));
            errorCodes.Add(new LinkErrorCode(ErrorCodeUnexpectedError, LinkExceptionTypeArea.Itinerary, LinkExceptionCategory.UnexpectedError, "MyItinerary", "Something went wrong during the XPath promotion. This payload might not be valid XML.", "Verify that the payload is valid XML"));
            return base.RegisterErrorCodes();
        }

        public override ILinkItineraryStep2 Create(IServiceProvider serviceProvider)
        {
            return serviceProvider.GetRequiredService<MyItineraryStep>();
        }
    }

    public class MyItineraryStep : ItineraryStepBase2<MyItineraryStepConfig>
    {
        private readonly ILogger<MyItineraryStep> logger;

        public MyItineraryStep(ILogger<MyItineraryStep> logger)
        {
            this.logger = logger;
        }

        public override string StepKeyName => "bizbrains-itinerary-mystep";

        protected override Task<ILinkMessage> Execute(ILinkMessage linkMessage, MyItineraryStepConfig config, CancellationToken cancellationToken)
        {
            logger.LogInformation($"Calling execute on {GetType()}");
            try
            {
                var xDocument = XDocument.Load(linkMessage.Body.Data);
                var xElement = xDocument.XPathSelectElement(config.PromotionXpath) ?? throw new LinkException($"The XPath {config.PromotionXpath} doesn't return any elements.", MyItineraryStepFactory.ErrorCodeXPath);

                linkMessage.Properties.Add(config.PromotionPropertyName, config.PromotionPropertyNamespace, xElement.Value); // Promote the value of the xpath to the given namespace and name
                linkMessage.Body.Data.Seek(0, SeekOrigin.Begin); // Remember to rewind the body-stream

                logger.LogInformation("All done!");
            }
            catch(Exception ex)
            {
                throw new LinkException("Something went wrong during the XPath promotion. This payload might not be valid XML.", MyItineraryStepFactory.ErrorCodeUnexpectedError, innerException: ex);
            }

            return Task.FromResult(linkMessage);
        }
    }

    public class MyItineraryStepConfig : LinkConfigBase
    {
        [LinkRequired]
        [LinkDisplay(Name = "XPath", GroupName = "XPath promotion", Description = "The XPath used to retrieve the value that should be promoted", Order = 1)]
        public string PromotionXpath { get; set; }
        [LinkRequired]
        [LinkDisplay(Name = "Context Property Namespace", GroupName = "XPath promotion", Order = 2)]
        public string PromotionPropertyNamespace { get; set; }
        [LinkRequired]
        [LinkDisplay(Name = "Context Property Key", GroupName = "XPath promotion", Order = 3)]
        public string PromotionPropertyName { get; set; }
    }
}

using Bizbrains.Link.Base;
using Bizbrains.Link.Base.Implementations.MessageProperties;
using Bizbrains.Link.Repositories.Configuration.DistributionModel;
using Bizbrains.Link.Repositories.Configuration.Partner;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace Bizbrains.Examples.ItineraryStep2
{
    public class MyItineraryStepFactory : LinkStepFactoryBase<ILinkItineraryStep2>
    {
        public override string StepDisplayName => "My itinerary step";

        public override string StepDescription => "This step does nothing but logging some info...";
        public override void ConfigureServices(IServiceCollection serviceCollection)
        {
            // We add our step to the service-collection, because dependency injection will then resolve any services, repositories, logging and other stuff we expect in our constructor
            serviceCollection.AddTransient<MyItineraryStep>();
            // Add additional services, if you have any...
        }

        public override ILinkItineraryStep2 Create(IServiceProvider serviceProvider)
        {
            return serviceProvider.GetRequiredService<MyItineraryStep>();
        }
    }

    public class MyItineraryStep : ItineraryStepBase2<MyItineraryStepConfig>
    {
        private readonly ILogger<MyItineraryStep> logger;
        private readonly IDistributionRepository distributionRepository;
        private readonly IPartnerRepository partnerRepository;

        public MyItineraryStep(ILogger<MyItineraryStep> logger, IDistributionRepository distributionRepository, IPartnerRepository partnerRepository)
        {
            this.logger = logger;
            this.distributionRepository = distributionRepository;
            this.partnerRepository = partnerRepository;
        }

        public override string StepKeyName => "bizbrains-itinerary-mystep";

        protected override async Task<ILinkMessage> Execute(ILinkMessage linkMessage, MyItineraryStepConfig config, CancellationToken cancellationToken)
        {
            // Access context-properties
            var accessor = new LinkPropertyAccessor(linkMessage);
            var distributionId = accessor.Distribution.Id.ValueMandatory; // ValueMandatory will throw an exception with a telling text about the property and the missing value.

            // Load distribution-entity
            var distributionEntity = await distributionRepository.GetById(distributionId, false);
            logger.LogInformation($"Distribution details - PartnerInId: {distributionEntity.PartnerInId}, PartnerOutId: {distributionEntity.PartnerOutId}");

            // Load sender-partner-entity
            var senderPartner = await partnerRepository.GetById(accessor.PartnerIn.Id.ValueMandatory);
            logger.LogInformation($"Sender partner-name: {senderPartner.Name}");

            return linkMessage;
        }
    }

    public class MyItineraryStepConfig : LinkConfigBase { }
}

using Bizbrains.Link.Base;
using Bizbrains.Link.Base.ConfigAttributes;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace Link.Examples.SendStep
{
    public class MySendStepFactory : LinkStepFactoryBase<ILinkTransportSend>
    {
        public override string StepDisplayName => "My Http Sender";

        public override string StepDescription => "This step will post the body of the LinkMessage to the configured http-address";
        public override void ConfigureServices(IServiceCollection serviceCollection)
        {
            // We add our step to the service-collection, because dependency injection will then resolve any services, repositories, logging and other stuff we expect in our constructor
            serviceCollection.AddTransient<MySendStep>();
            // Add additional services, if you have any...
        }

        public override ILinkTransportSend Create(IServiceProvider serviceProvider)
        {
            return serviceProvider.GetRequiredService<MySendStep>();
        }
    }

    public class MySendStep : TransportSendBase<MySendStepConfig>
    {
        private readonly ILogger<MySendStep> logger;

        public MySendStep(ILogger<MySendStep> logger)
        {
            this.logger = logger;
        }

        public override string StepKeyName => "bizbrains-transport-send-httpsender";

        protected override string GenerateDisplayAddress(MySendStepConfig config)
        {
            // The display-address is used when creating the transport-type in Link.
            // Then this method will be invoked, and you can put together whatever makes sense for your transport-type.
            return $"{config.Url} ({config.HttpVerb})";
        }

        protected override async Task Send(ILinkMessage linkMessage, ILinkSendProvider sendProvider, MySendStepConfig config, CancellationToken ct)
        {
            var httpClient = new HttpClient();
            var httpMethod = config.HttpVerb == HttpVerb.Put ? HttpMethod.Put : HttpMethod.Post;
            var httpRequest = new HttpRequestMessage(httpMethod, config.Url);
            httpRequest.Content = new StreamContent(linkMessage.Body.Data);

            logger.LogInformation($"Calling {config.Url} ({config.HttpVerb})");
            var response = await httpClient.SendAsync(httpRequest, ct);
            logger.LogInformation("Http call done - reading response...");

            var body = await response.Content.ReadAsStreamAsync();

            logger.LogInformation($"Response read. Length: {body.Length}. Setting body on LinkMessage...");
            linkMessage.SetBody(body);
        }
    }

    public class MySendStepConfig : LinkConfigBase
    {
        [LinkRequired]
        [LinkDisplay(Name = "Url", GroupName = "Http", Order = 1)]
        public string Url { get; set; }

        [LinkRequired]
        [LinkDisplay(Name = "Http method", GroupName = "Http", Order = 2)]
        [LinkDefaultValue(nameof(HttpVerb.Post))]
        public HttpVerb HttpVerb { get; set; } // Enums will be presented as dropdowns
    }

    public enum HttpVerb
    {
        // Use the LinkEnum attribute to put a display-name on an enum.
        [LinkEnum("Post method")]
        Post,
        [LinkEnum("Put method")]
        Put
    }
}

using Bizbrains.Link.Base;
using Bizbrains.Link.Base.ConfigAttributes;
using Bizbrains.Link.Base.DuplicateCheck;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace Link.Examples.DuplicateCheck
{
    public class MyDuplicateCheckFactory : LinkStepFactoryBase<ILinkDuplicateCheck2>
    {
        public override string StepDisplayName => "My Duplicate Check";

        public override string StepDescription => "Finds a value in the payload at a specific position to use in the duplicate check framework";

        public override void ConfigureServices(IServiceCollection serviceCollection)
        {
            // We add our step to the service-collection, because dependency injection will then resolve any services, repositories, logging and other stuff we expect in our constructor
            serviceCollection.AddTransient<MyDuplicateCheck>();
            // Add additional services, if you have any...
        }

        public override ILinkDuplicateCheck2 Create(IServiceProvider serviceProvider)
        {
            return serviceProvider.GetRequiredService<MyDuplicateCheck>();
        }
    }

    internal class MyDuplicateCheck : DuplicateCheckBase2<MyDuplicateCheckConfig>
    {
        private readonly ILogger<MyDuplicateCheck> logger;

        public MyDuplicateCheck(ILogger<MyDuplicateCheck> logger)
        {
            this.logger = logger;
        }

        public override DuplicateCheckType DuplicateCheckType => DuplicateCheckType.Interchange;

        public override string StepKeyName => "bizbrains-duplicate-check-myduplicatecheck";

        protected override Task<DuplicateCheckResult> GetDuplicateCheckValue(ILinkMessage message, MyDuplicateCheckConfig config, CancellationToken cancellationToken)
        {
            logger.LogInformation("Starting MyDuplicateCheck");

            var reader = new StreamReader(message.Body.Data);
            var payload = reader.ReadToEnd();

            // Find the value based on the position specified in the config.
            var payloadValue = payload[config.PositionFrom..config.PositionTo];

            // Remember to rewind the body-stream
            message.Body.Data.Seek(0, SeekOrigin.Begin);

            var result = new DuplicateCheckResult()
            {
                CheckValue = payloadValue
            };

            logger.LogInformation("Finished MyDuplicateCheck");
            return Task.FromResult(result);
        }
    }

    public class MyDuplicateCheckConfig : ILinkConfig
    {
        [LinkRequired]
        [LinkDisplay(Name = "Position from", GroupName = "MyDuplicateCheck Config", Description = "Starting position of value in payload", Order = 1)]
        public int PositionFrom { get; set; }

        [LinkRequired]
        [LinkDisplay(Name = "Position to", GroupName = "MyDuplicateCheck Config", Description = "Ending position of value in payload", Order = 2)]
        public int PositionTo { get; set; }
    }
}

using Bizbrains.Link.Base;
using Bizbrains.Link.Base.ConfigAttributes;
using Bizbrains.Link.Base.Exceptions;
using Bizbrains.Link.Base.Implementations;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System.Text;

namespace Link.Examples.FormatTypeProbe
{
    public class MyFormatProbeFactory : LinkStepFactoryBase<ILinkFormatTypeProbe2>
    {
        public override string StepDisplayName => "MyFormat Probe";

        public override string StepDescription => "Checks if the paylod is of type MyFormat";

        public override void ConfigureServices(IServiceCollection serviceCollection)
        {
            // We add our step to the service-collection, because dependency injection will then resolve any services, repositories, logging and other stuff we expect in our constructor
            serviceCollection.AddTransient<MyFormatProbe>();
            // Add additional services, if you have any...
        }

        public override ILinkFormatTypeProbe2 Create(IServiceProvider serviceProvider)
        {
            return serviceProvider.GetRequiredService<MyFormatProbe>();
        }

        public const string MySettingInvalidError = "A1B2C"; // Generate the error-code in the Link UI (Developer -> Error codes -> Generate code)
        public override IEnumerable<LinkErrorCode> RegisterErrorCodes()
        {
            var errorCodes = new List<LinkErrorCode>();
            errorCodes.Add(new LinkErrorCode(MySettingInvalidError, LinkExceptionTypeArea.Initialize, LinkExceptionCategory.MissingConfigurationError, "MyFormatProbe", "Configuration field MySetting contains an invalid value", "Only use valid values"));
            return base.RegisterErrorCodes();
        }
    }

    internal class MyFormatProbe : LinkFormatTypeProbeBase2<MyFormatProbeConfig>
    {
        private readonly ILogger<MyFormatProbe> logger;

        public MyFormatProbe(ILogger<MyFormatProbe> logger)
        {
            this.logger = logger;
        }

        public override Task<bool> Probe(Stream payload, Encoding encoding, MyFormatProbeConfig config, CancellationToken cancellationToken)
        {
            try
            {
                logger.LogInformation("Probing for MyFormat");

                //Implement logic for checking if payload is of type MyFormat

                if (config.MySetting != "ValidValue")
                {
                    throw new LinkException($"The value \"{config.MySetting}\" is not a valid value for field MySetting", MyFormatProbeFactory.MySettingInvalidError);
                }

                return Task.FromResult(true);
            }
            catch (Exception)
            {
                return Task.FromResult(false);
            }
        }
    }

    public class MyFormatProbeConfig : LinkConfigBase
    {
        [LinkRequired]
        [LinkDisplay(Name = "MySetting", GroupName = "MyFormat Config", Description = "Used for probing MyFormat", Order = 1)]
        public string MySetting { get; set; }
    }
}

using Bizbrains.Link.Base;
using Bizbrains.Link.Base.ConfigAttributes;
using Bizbrains.Link.Base.TestTool;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System.Text;
using System.Xml;
using System.Xml.Linq;

namespace Link.Examples.Compare
{
    public class MyXmlCompareFactory : LinkFactoryBase<ITestToolCompare>
    {
        public override void ConfigureServices(IServiceCollection serviceCollection)
        {
            serviceCollection.AddTransient<MyXmlCompare>();
        }

        public override ITestToolCompare Create(IServiceProvider serviceProvider)
        {
            return serviceProvider.GetRequiredService<MyXmlCompare>();
        }
    }

    public class MyXmlCompare : TestToolCompareBase<MyXmlCompareConfig>
    {
        private readonly ILogger logger;
        public override string StepKeyName => "bizbrains-testtool-myxmlcompare";

        public MyXmlCompare(ILogger<MyXmlCompare> logger)
        {
            this.logger = logger;
        }

        public override Task<TestToolResult> Compare(TestToolDocumentContainer documentContainer, CancellationToken cancellationToken)
        {
            TestToolResult result = new TestToolResult();
            List<TestToolErrorDescription> errors = new List<TestToolErrorDescription>();
            //
            //Convert incomming streams to more easily handled objects.
            //

            cancellationToken.ThrowIfCancellationRequested();

            //
            //Iterate through xml documents and compare element by element
            //

            result.Errors = errors;

            if (errors.Count > 0)
            {
                result.Success = false;
            }
            else
            {
                result.Success = true;
            }
            return Task.FromResult(result);
        }

        public override Task<TestToolDocumentContainer> Prepare(TestToolDocumentContainer documentContainer, MyXmlCompareConfig config, CancellationToken cancellationToken)
        {
            //
            //Convert incomming streams to more easily handled objects.
            //

            cancellationToken.ThrowIfCancellationRequested();

            //
            //Prepare both streams based on config. could be removing nodes or changing data so they will compare(like date time objects that will always be different.
            //

            //
            // Convert manipulated objects back to streams and return them
            //

            TestToolDocumentContainer resultContainer = new TestToolDocumentContainer();
            resultContainer.OriginalDocument = StringToStream(xmlDoc1.OuterXml, documentContainer.OriginalDocumentEncoding);
            resultContainer.OriginalDocumentEncoding = documentContainer.OriginalDocumentEncoding;
            resultContainer.TestDocument = StringToStream(xmlDoc2.OuterXml, documentContainer.TestDocumentEncoding);
            resultContainer.TestDocumentEncoding = documentContainer.TestDocumentEncoding;

            return Task.FromResult(resultContainer);
        }


        private static Stream StringToStream(string src, Encoding encoding)
        {
            byte[] byteArray = encoding.GetBytes(src);
            return new MemoryStream(byteArray);
        }
    }



    public class MyXmlCompareConfig : ILinkConfig
    {
        [LinkDisplay(Name = "Xpath", GroupName = "Xpath 1", Order = 10)]
        public string Xpath1 { get; set; } = "";

        [LinkDefaultValue(nameof(PrepareConfig.Ignore))]
        [LinkDisplay(Name = "Xpath Action", Description = "What to do with this xpath. Either remove the node or set the content to fixed value that will compare", GroupName = "Xpath 1", Order = 11)]
        public PrepareConfig PrepareConfig1 { get; set; }

        [LinkDisplay(Name = "Xpath", GroupName = "Xpath 2", Order = 20)]
        public string Xpath2 { get; set; } = "";

        [LinkDefaultValue(nameof(PrepareConfig.Ignore))]
        [LinkDisplay(Name = "Xpath Action", Description = "What to do with this xpath. Either remove the node or set the content to fixed value that will compare", GroupName = "Xpath 2", Order = 21)]
        public PrepareConfig PrepareConfig2 { get; set; }


    }


    public enum PrepareConfig
    {
        Ignore,
        Remove
    }
}

using Bizbrains.Link.Base;
using Bizbrains.Link.Base.DocumentTypeClassifierResolver;
using Microsoft.Extensions.DependencyInjection;

namespace Bizbrains.Link.SystemArtifacts.DocumentTypeClassifierResolvers.My;

public class MyDocumentTypeClassifierResolverFactory : LinkStepFactoryBase<ILinkDocumentTypeClassifierResolver2>
{
    public override string StepDisplayName => "Bizbrains Document Type Classifier Resolver My";

    public override string StepDescription => "Document Type Classifier Resolver plugin for MY documents";

    public override ILinkDocumentTypeClassifierResolver2 Create(IServiceProvider serviceProvider) => serviceProvider.GetRequiredService<MyDocumentTypeClassifierResolver>();

    public override void ConfigureServices(IServiceCollection serviceCollection)
    {
        base.ConfigureServices(serviceCollection);
        serviceCollection.AddTransient<MyDocumentTypeClassifierResolver>();
    }
}

public class MyDocumentTypeClassifierResolver : DocumentTypeClassifierResolverBase2<MyDocumentTypeClassifierResolverConfig>
{
    public override string StepKeyName => "system-document-type-classifier-resolver-my";

    protected override async Task<DocumentTypeClassifierResolverResult> Resolve(ILinkMessage message, IEnumerable<MyDocumentTypeClassifierResolverConfig> configurations, CancellationToken cancellationToken)
    {
        await Task.CompletedTask;

        var messageType = "MyMessageType";
        return new DocumentTypeClassifierResolverResult() { Result = configurations.FirstOrDefault(c => c.MessageType == messageType) };
    }
}

public class MyDocumentTypeClassifierResolverConfig : ILinkConfig
{
    public string MessageType { get; set; }
}