/// <summary>Initializes the transport by ensuring that the input queue has been created</summary>
public void Initialize()
{
_log.Info("Initializing Kafka transport with queue {queueName}", Address);
var builder = new ProducerBuilder <Ignore, TransportMessage>(_producerConfig)
.SetKeySerializer(new IgnoreSerializer())
.SetValueSerializer(new TransportMessageSerializer())
.SetLogHandler(ProducerOnLog)
.SetStatisticsHandler(ProducerOnStatistics)
.SetErrorHandler(ProducerOnError);
try
{
_producer = builder.Build();
}
catch (DllNotFoundException)
{ // Try loading librdkafka.dll
if (!Library.IsLoaded)
{
string directory = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().GetName().CodeBase.Substring(8));
var pathToLibrd = System.IO.Path.Combine(directory, $"librdkafka\\{(Environment.Is64BitOperatingSystem ? "x64" : "x86")}\\librdkafka.dll");
_log.Info($"librdkafka is not loaded. Trying to load {pathToLibrd}");
Library.Load(pathToLibrd);
_log.Info($"Using librdkafka version: {Library.Version}");
}
_producer = builder.Build();
}
_queueSubscriptionStorage?.Initialize();
}
private async Task NotificarImpostoCalculado(Imposto imposto)
{
var impostoJson = JsonSerializer.Serialize(imposto);
var config = new ProducerConfig {
BootstrapServers = kafkaConfig.Value.BootstrapServers
};
var producerBuilder = new ProducerBuilder <Null, string>(config);
using (var producer = producerBuilder.Build())
{
try
{
Console.WriteLine($"Produzindo mensagem stur_imposto_calculado: ${impostoJson}");
await producer.ProduceAsync("stur-imposto-calculado", new Message <Null, string>
{
Value = impostoJson
});
Console.WriteLine("$Mensagem enviada!");
}
catch (ProduceException <Null, Imposto> e)
{
Console.WriteLine(e.Message);
throw e;
}
}
}
private void StartProducer(double seed)
{
Console.WriteLine("Producing {0}", seed);
var producerBuilder = new ProducerBuilder <string, Payload>(_config);
producerBuilder.SetValueSerializer(new ProtoSerializer <Payload>());
using (var producer = producerBuilder.Build())
{
for (long i = 0; i < 1000; i++)
{
string payload = $"{seed}-{i}".ToString(CultureInfo.InvariantCulture);
string key = "sc-" + seed;
var message = new Message <string, Payload>
{
Key = key,
Value = new Payload
{
Key = key,
ProducerId = _settings.ProducerId.ToString(),
Value = payload
}
};
producer.Produce(_settings.Topic, message);
}
producer.Flush(TimeSpan.FromSeconds(30));
}
Console.WriteLine("End of {0}", seed);
}
public IProducer <Null, TMessage> GetProducer <TMessage>()
{
var options = _optionsProvider.Value;
var producer = _producers.GetOrAdd(typeof(TMessage), type =>
{
var logger = _loggerFactory.CreateLogger <IProducer <Null, TMessage> >();
var builder = new ProducerBuilder <Null, TMessage>(_producerConfig)
.SetValueSerializer(new JsonSerializer <TMessage>(options.CreateJsonOptions()))
.SetErrorHandler((p, e) =>
{
var logLevel = e.GetLogLevel();
var category = e.GetCategory();
logger.Log(logLevel, "Kafka producer error '{Code}' - '{Reason}', category '{Category}'", e.Code, e.Reason, category);
})
.SetLogHandler((p, m) =>
{
var logLevel = m.Level.GetLogLevel();
logger.Log(logLevel, "Kafka log event {Name} ({Facility}) - {Message}", m.Name, m.Facility, m.Message);
});
return(builder.Build());
});
return((IProducer <Null, TMessage>)producer);
}
public IProducer <string, string> CreateProducer(ProducerConfig producerConfig)
{
var pb = new ProducerBuilder <string, string>(producerConfig);
producer = pb.Build();
return(producer);
}
public IProducer <string, byte[]> CreateProducer(ClusterSettings clusterSettings, TopicProducerSettings topicProducerSettings)
{
if (topicProducerSettings == null)
{
throw new ArgumentNullException(nameof(topicProducerSettings));
}
if (!topicProducerSettings.Enabled)
{
return(null);
}
var config = clusterSettings.ToClientConfig <ProducerConfig>(c =>
{
c.Acks = (Acks?)topicProducerSettings.Acks;
});
var builder = new ProducerBuilder <string, byte[]>(config)
.SetKeySerializer(Utf8Serializer.Instance);
if (CompressionHandlerFactory.ResolveCompressionHandler(topicProducerSettings.MessageCompressionType, out var compressionHandler))
{
builder.SetValueSerializer(compressionHandler);
}
var producer = builder.Build();
this.producers.Add(producer);
return(producer);
}
static void Main(string[] args)
{
var builder = new ProducerBuilder <Confluent.Kafka.Null, string>()
.UseSectionConfiguration()
.UseOptions(opt =>
{
opt.ErrorHandler = (_, e) => { Console.WriteLine(e); };
});
using (var producer = builder.Build())
{
string text = null;
while (true)
{
text = Console.ReadLine();
if (text != "exit")
{
producer.ProduceAsync("test", new Confluent.Kafka.Message <Confluent.Kafka.Null, string>()
{
Key = null, Value = text
});
}
else
{
break;
}
}
producer.Flush();
}
}
/// <summary>
/// 生产
/// </summary>
/// <param name="Key">Message.Key 做消息指定分区投放有用的</param>
/// <param name="Value">Message.Value</param>
/// <param name="Topic">主题</param>
public void Produce(TKey Key, TValue Value, string Topic)
{
var producerBuilder = new ProducerBuilder <TKey, TValue>(ProducerConfig);
producerBuilder.SetValueSerializer(new KafkaConverter <TValue>());//设置序列化方式
using var producer = producerBuilder.Build();
try
{
producer.Produce(Topic, new Message <TKey, TValue>
{
Key = Key,
Value = Value
}, (result) =>
{
if (result.Error.IsError)
{
Logger.Error(LoggerType.KafkaException, $"Topic:{Topic},ServerIp:{KafkaHelper.GetServerIp()},ServerName:{ KafkaHelper.GetServerName()}", null, $"Delivery Error:{result.Error.Reason}");
}
});//Value = JsonConvert.SerializeObject(value)
}
catch (ProduceException <Null, string> ex)
{
Logger.Error(LoggerType.KafkaException, $"Topic:{Topic},Delivery failed: { ex.Error.Reason}", null, ex.Message + ex.StackTrace);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
await BeginProduction();
var producerBuilder = new ProducerBuilder <int, string>(_producerConfiguration);
using (var p = producerBuilder.Build())
{
while (!stoppingToken.IsCancellationRequested)
{
var dr = await p.ProduceAsync(_configuration["Topic"], new Message <int, string>
{
// Only keys 1 - 9 exist in the database, so to create some failures we'll pick PKs that
// don't exist.
Key = new Random().Next(1, 18),
Value = $"{new Random().Next(1, 180)}"
});
Console.WriteLine($"Delivered '{dr.Value}' to '{dr.TopicPartitionOffset}'");
// sleep 1s, but respond to cancellation
stoppingToken.WaitHandle.WaitOne(TimeSpan.FromSeconds(1));
}
}
}
public async Task <IActionResult> CreateAsync([FromBody] CreateNewsCommand command)
{
if (command == null)
{
return(BadRequest());
}
var @event = new CreateNewsEvent
{
Name = command.Name,
Description = command.Description
};
var value = JsonSerializer.Serialize(@event);
var message = new Message <Null, string>
{
Value = value
};
using var producer = _producerBuilder.Build();
await producer.ProduceAsync(Topic, message);
return(Ok());
}
public IProducer <Null, byte[]> CreateProducer(
KafkaQueueConfiguration config,
Action <IProducer <Null, byte[]>, LogMessage> logHandler = null,
Action <IProducer <Null, byte[]>, Error> errorHandler = null)
{
config.ThrowIfNull(nameof(config));
var builder = new ProducerBuilder <Null, byte[]>(new ProducerConfig
{
BootstrapServers = $"{config.Server}",
SaslKerberosKeytab = config.KeyTab,
SaslKerberosPrincipal = config.User,
SaslKerberosServiceName = config.ServiceName,
SecurityProtocol = config.Protocol,
SaslMechanism = config.Mechanism,
Debug = config.Debug
});
if (logHandler != null)
{
builder.SetLogHandler(logHandler);
}
if (errorHandler != null)
{
builder.SetErrorHandler(errorHandler);
}
return(builder.Build());
}
private void Init(ProducerConfig config)
{
if (_logger.IsDebug)
{
_logger.Debug($"Initializing {Name} type producer for Kafka...");
}
try
{
CachedSchemaRegistryClient schemaRegistry = new CachedSchemaRegistryClient(new[]
{
new KeyValuePair <string, string>(SchemaRegistryConfig.PropertyNames.SchemaRegistryUrl, _schemaRegistryUrl)
});
var blockAvroSerializer = new AvroSerializer <Block>(schemaRegistry).AsSyncOverAsync();
var txAvroSerializer = new AvroSerializer <FullTransaction>(schemaRegistry).AsSyncOverAsync();
ProducerBuilder <Null, Block> blockProducerBuilder = new ProducerBuilder <Null, Block>(config);
blockProducerBuilder.SetValueSerializer(blockAvroSerializer);
blockProducerBuilder.SetErrorHandler((s, e) => _logger.Error(e.ToString()));
ProducerBuilder <Null, FullTransaction> txProducerBuilder = new ProducerBuilder <Null, FullTransaction>(config);
txProducerBuilder.SetValueSerializer(txAvroSerializer);
txProducerBuilder.SetErrorHandler((s, e) => _logger.Error(e.ToString()));
_producerBlocks = blockProducerBuilder.Build();
_producerTransactions = txProducerBuilder.Build();
_initialized = true;
if (_logger.IsDebug)
{
_logger.Debug($"Initialized {Name} type producer for Kafka.");
}
}
catch (Exception e)
{
_logger.Error(e.Message, e);
}
}
private static async void Consumer_Received(object sender, BasicDeliverEventArgs e)
{
try
{
var msg = Encoding.UTF8.GetString(e.Body);
Debug.WriteLine("Msg recebida: " + msg);
var config = new ProducerConfig();
config.BootstrapServers = "23.99.218.43:9092";
var builder = new ProducerBuilder <string, string>(config);
using (var producer = builder.Build())
{
string topic = "15netkafka";
var message = new Message <string, string>
{
Key = "Grupo1",
Value = msg
};
await producer.ProduceAsync(topic, message);
}
}
catch
{
Console.WriteLine("Erro na msg recebida!");
}
}
static void Main(string[] args)
{
var producerConfig = new ProducerConfig
{
Acks = Acks.All,
BootstrapServers = "192.168.56.1:9092",
SaslMechanism = SaslMechanism.Plain,
SaslPassword = "******",
SaslUsername = "******",
SecurityProtocol = SecurityProtocol.SaslPlaintext
};
var topic = "test";
var builder = new ProducerBuilder <String, String>(producerConfig);
Console.WriteLine("Enter exit for stopping producer, or enter KEY:VALUE");
using (var producer = builder.Build())
{
string s = Console.ReadLine();
while (!s.Contains("exit", StringComparison.InvariantCultureIgnoreCase))
{
string[] r = s.Split(":");
producer.Produce(topic, new Message <string, string> {
Key = r[0], Value = r[1]
}, (d) =>
{
if (d.Status == PersistenceStatus.Persisted)
{
Console.WriteLine("Message sent !");
}
});
s = Console.ReadLine();
}
}
}
private static async Task <IProducer <OrderKey, OrderEventRecord> > CreateProducer(
ISchemaRegistryClient registryClient,
AutomaticRegistrationBehavior automaticRegistrationBehavior)
{
var schemaBuilder = new SchemaBuilder(
SchemaBuilder.CreateDefaultCaseBuilders()
.Prepend(builder => new OrderEventUnionSchemaBuilderCase(builder)));
using var serializerBuilder = new SchemaRegistrySerializerBuilder(
registryClient,
schemaBuilder,
serializerBuilder: new BinarySerializerBuilder(
BinarySerializerBuilder.CreateDefaultCaseBuilders()
.Prepend(builder => new OrderEventUnionSerializerBuilderCase(builder))));
var producerBuilder = new ProducerBuilder <OrderKey, OrderEventRecord>(
new ProducerConfig
{
BootstrapServers = BootstrapServers,
});
await producerBuilder.SetAvroKeySerializer(
registryClient,
SubjectNameStrategy.Topic.ConstructKeySubjectName(Topic),
automaticRegistrationBehavior);
await producerBuilder.SetAvroValueSerializer(
serializerBuilder,
SubjectNameStrategy.Topic.ConstructKeySubjectName(Topic),
automaticRegistrationBehavior);
return(producerBuilder.Build());
}
public static void Producer()
{
var config = new ProducerConfig {
BootstrapServers = mBootstrapServers
};
Action <DeliveryReport <Null, string> > handler = r =>
Console.WriteLine(!r.Error.IsError
? $"Delivered message to {r.TopicPartitionOffset}"
: $"Delivery Error: {r.Error.Reason}");
var producerBuilder = new ProducerBuilder <Null, string>(config);
// 错误日志监视
producerBuilder.SetErrorHandler((p, msg) =>
{
Console.WriteLine($"Producer_Erro信息：Code：{msg.Code}；Reason：{msg.Reason}；IsError：{msg.IsError}");
});
using (var producer = producerBuilder.Build())
{
for (int i = 0; i < 5; i++)
{
// 异步发送消息到主题
producer.Produce(mTopick, new Message <Null, string> {
Value = i.ToString()
}, handler);
}
// 3后 Flush到磁盘
producer.Flush(TimeSpan.FromSeconds(3));
}
}
public async Task StartAsync(CancellationToken cancellationToken = default)
{
var config = new ProducerConfig
{
BootstrapServers = brokerList,
};
var builder = new ProducerBuilder <string, User>(config)
.SetValueSerializer(new ProtobufSerializer <User>());
using (var producer = builder.Build())
{
for (int i = 1; i <= this.totalMessages && !cancellationToken.IsCancellationRequested; ++i)
{
var name = GetName();
var msg = new Message <string, User>()
{
Key = name,
Value = new User()
{
FavoriteColor = "Green",
FavoriteNumber = randomizer.Next(),
Name = name,
}
};
var deliveryReport = await producer.ProduceAsync(this.topicName, msg);
Console.WriteLine($"Message {i} sent (value: '{msg.Value}'), offset: {deliveryReport.Offset}, partition: {deliveryReport.Partition}");
}
}
}
public KafkaEventPublisher(
string topic,
KafkaSettings settings,
ISerializer <TKey> keySerializer,
ISerializer <TEvent> valueSerializer,
Func <TEvent, TKey> keyProvider)
{
_topic = topic;
_keyProvider = keyProvider;
var config = new ProducerConfig
{
BootstrapServers = string.Join(",", settings.BootstrapServers),
Partitioner = Partitioner.Consistent
};
var producerBuilder = new ProducerBuilder <TKey, TEvent>(config)
.SetValueSerializer(valueSerializer);
if (keySerializer != null)
{
producerBuilder.SetKeySerializer(keySerializer);
}
_producer = producerBuilder.Build();
}
public async Task <string> SendMessage(CarRequest carRequest)
{
var key = Guid.NewGuid().ToString();
var carObjectMessage = JsonConvert.SerializeObject(carRequest);
var config = new ProducerConfig
{
BootstrapServers = "localhost:9092",
MessageTimeoutMs = 5000,
MessageSendMaxRetries = 5
};
ProducerBuilder <string, string> kafkaProducer = new ProducerBuilder <string, string>(config);
using (var producer = kafkaProducer.Build())
{
try
{
var sendResult = producer.ProduceAsync("kafka-topic",
new Message <string, string> {
Key = key, Value = carObjectMessage
}).GetAwaiter().GetResult();
await Task.Delay(100);
return(key);
}
catch (ProduceException <string, string> e)
{
return($"Delivery messaging failed: {e.Error.Reason}");
}
}
}
public async Task CreateProducer()
{
var config = new ProducerConfig
{
BootstrapServers = SERVER
};
var builder = new ProducerBuilder <Null, string>(config);
using (var producer = builder.Build())
{
try
{
Parallel.For(0, 10
, async(index) =>
{
var message = $"Vral {index}";
var result = await producer.ProduceAsync(
TOPIC,
new Message <Null, string> {
Value = message
});
Console.WriteLine($"Delivered ({ result.Value}) > ({result.TopicPartitionOffset})");
});
await Task.CompletedTask;
}
catch (ProduceException <Null, string> exception)
{
Console.WriteLine($"Delivery failed: {exception.Error.Reason}");
}
}
}
private static void Main(string[] args)
{
var producerConfig = new ProducerConfig
{
Acks = Acks.All,
BootstrapServers = "localhost:29092"
};
var topic = args.Length > 0 ? args[0] : "test";
var builder = new ProducerBuilder <String, String>(producerConfig);
Console.WriteLine($"Writting in {topic} topic");
Console.WriteLine("Enter exit for stopping producer, or enter KEY:VALUE");
using (var producer = builder.Build())
{
string s = Console.ReadLine();
while (!s.Contains("exit", StringComparison.InvariantCultureIgnoreCase))
{
string[] r = s.Split(":");
producer.Produce(topic, new Message <string, string> {
Key = r[0], Value = r[1]
}, (d) =>
{
if (d.Status == PersistenceStatus.Persisted)
{
Console.WriteLine("Message sent !");
}
});
s = Console.ReadLine();
}
}
}
private IProducer <TKey, TValue> BuildProducer <TKey, TValue>(ProducerConfig configuration, Action <ProducerBuilder <TKey, TValue> > configure)
{
var producerBuilder = new ProducerBuilder <TKey, TValue>(configuration);
configure?.Invoke(producerBuilder);
return(producerBuilder.Build());
}
public KafkaOutput(KafkaLoggingOptions options) : base(options.BufferedOutputOptions)
{
if (string.IsNullOrWhiteSpace(options.Topic))
{
throw new ArgumentException("Must not empty", $"{nameof(options)}.{nameof(options.Topic)}");
}
if (options.Serializer == null)
{
throw new ArgumentException("Must not null", $"{nameof(options)}.{nameof(options.Serializer)}");
}
_options = options;
if (!string.IsNullOrWhiteSpace(_options.ContentType))
{
_headers.Add("Content-Type", Encoding.UTF8.GetBytes(_options.ContentType));
}
var pb = new ProducerBuilder <Guid, IReadOnlyDictionary <string, object?> >(_options.ProducerConfig)
.SetKeySerializer(new GuiSerializer())
.SetValueSerializer(new ObjectSerializer(_options.Serializer));
if (_options.KafkaErrorHandler != null)
{
var handler = _options.KafkaErrorHandler;
pb.SetErrorHandler((_, error) => handler(error));
}
_producer = pb.Build();
}
static void Main(string[] args)
{
var config = new ProducerConfig
{
BootstrapServers = "192.168.56.1:9093",
ClientId = "producer-ssl-01",
SaslMechanism = SaslMechanism.Plain,
SecurityProtocol = SecurityProtocol.SaslSsl,
SaslUsername = "******",
SaslPassword = "******",
SslEndpointIdentificationAlgorithm = SslEndpointIdentificationAlgorithm.None,
SslCaLocation = @"root.crt",
SslCertificateLocation = @"producer_client.crt",
SslKeyLocation = @"producer_client.key"
};
var builder = new ProducerBuilder <string, string>(config);
string line = "";
using (var producer = builder.Build())
{
var rd = new Random();
while (!line.Contains("exit", StringComparison.InvariantCultureIgnoreCase))
{
producer.Produce("test", new Message <string, string> {
Key = $"{rd.Next(0,100)}",
Value = $"{rd.Next(0,10)}-{rd.Next(0,100)}"
});
line = Console.ReadLine();
}
}
}
/// <summary>
/// Submitts messages to kafka on a given topic and using the given bootstrap servers.
/// This method will create a new producer for every message submitted.
/// </summary>
/// <param name="subject">The <c>EventClient</c> to extend</param>
/// <param name="topic">The topic to produce messages to</param>
/// <param name="bootstrapServers">the boostrap servers</param>
/// <returns>the modified event client.</returns>
public static EventClient UseKafka(this EventClient subject, string topic, string bootstrapServers)
{
var config = new ProducerConfig {
BootstrapServers = bootstrapServers
};
var builder = new ProducerBuilder <string, string>(config);
subject.UseHandle(
async evnt =>
{
using (var producer = builder.Build())
{
try
{
var kafkaEvent = new KafkaEvent {
Tags = evnt.Tags, Content = JObject.Parse(evnt.Content)
};
var strContent = await Task.Run(() => JsonConvert.SerializeObject(kafkaEvent));
await producer.ProduceAsync(topic, new Message <string, string> {
Key = evnt.Name, Value = strContent
});
}
catch (ProduceException <string, string> e)
{
Console.WriteLine($"Delivery to Kafka failed: {e.Error.Reason}");
throw e;
}
}
});
return(subject);
}
public ProducerClient(IHostingEnvironment env, IConfiguration globalconf)
{
_globalconf = globalconf;
string sslCaLocation = $@"{ApplicationEnvironment.ApplicationBasePath}{globalconf.GetValue<string>("Kafka:Cert")}";
producerConfig = new ProducerConfig
{
BootstrapServers = globalconf.GetValue <string>("Kafka:BootstrapServers"),
ApiVersionFallbackMs = 0,
//Debug = "security,broker,protocol"
};
if (globalconf.GetValue <bool>("Kafka:UseSSL"))
{
producerConfig.SecurityProtocol = SecurityProtocol.SaslSsl;
producerConfig.SaslMechanism = SaslMechanism.Plain;
producerConfig.SslCaLocation = sslCaLocation;
}
if (globalconf.GetValue <bool>("Kafka:RequireLogin"))
{
producerConfig.SaslUsername = globalconf.GetValue <string>("Kafka:Username");
producerConfig.SaslPassword = globalconf.GetValue <string>("Kafka:Password");
}
//if (env.IsDevelopment())
//{
// producerConfig = new ProducerConfig
// {
// BootstrapServers = globalconf.GetValue<string>("Kafka:BootstrapServers"),
// SecurityProtocol = SecurityProtocol.SaslSsl,
// SaslMechanism = SaslMechanism.Plain,
// SaslUsername = globalconf.GetValue<string>("Kafka:Username"),
// SaslPassword = globalconf.GetValue<string>("Kafka:Password"),
// SslCaLocation = sslCaLocation,
// ApiVersionFallbackMs = 0,
// Debug = "security,broker,protocol"
// };
// producerConfig = new ProducerConfig { BootstrapServers = "localhost:9092" };
//}
//else
//{
// producerConfig = new ProducerConfig
// {
// BootstrapServers = globalconf.GetValue<string>("Kafka:BootstrapServers"),
// SecurityProtocol = SecurityProtocol.SaslSsl,
// SaslMechanism = SaslMechanism.Plain,
// SaslUsername = globalconf.GetValue<string>("Kafka:Username"),
// SaslPassword = globalconf.GetValue<string>("Kafka:Password"),
// SslCaLocation = sslCaLocation,
// ApiVersionFallbackMs = 0,
// };
//}
var producerBuilder = new ProducerBuilder <Null, T>(producerConfig);
producerBuilder.SetValueSerializer(new KafkaByteSerializer <T>());
producer = producerBuilder.Build();
}
public static ProducerSubmission WithSICCodes(List <SICCode> sicCodes)
{
var builder = new ProducerBuilder();
builder.sicCodes = sicCodes;
return(builder.Build());
}
public static ProducerSubmission WithCeaseToExist(DateTime?ceaseToExist)
{
var builder = new ProducerBuilder();
builder.ceaseToExist = ceaseToExist;
return(builder.Build());
}
public static ProducerSubmission WithProducerBusiness(ProducerBusiness producerBusiness)
{
var builder = new ProducerBuilder();
builder.producerBusiness = producerBusiness;
return(builder.Build());
}
public static ProducerSubmission WithBrandNames(List <BrandName> brandNames)
{
var builder = new ProducerBuilder();
builder.brandNames = brandNames;
return(builder.Build());
}
public static ProducerSubmission WithObligationType(ObligationType obligationType)
{
var builder = new ProducerBuilder();
builder.obligationType = obligationType;
return builder.Build();
}
public static ProducerSubmission WithAnnualTurnover(int annualTurnover)
{
var builder = new ProducerBuilder();
builder.annualTurnover = annualTurnover;
return builder.Build();
}
public static ProducerSubmission VatRegistered(bool vatRegistered)
{
var builder = new ProducerBuilder();
builder.vatRegistered = vatRegistered;
return builder.Build();
}
public static ProducerSubmission WithSICCodes(List<SICCode> sicCodes)
{
var builder = new ProducerBuilder();
builder.sicCodes = sicCodes;
return builder.Build();
}
public static ProducerSubmission WithCeaseToExist(DateTime? ceaseToExist)
{
var builder = new ProducerBuilder();
builder.ceaseToExist = ceaseToExist;
return builder.Build();
}
public static ProducerSubmission WithBrandNames(List<BrandName> brandNames)
{
var builder = new ProducerBuilder();
builder.brandNames = brandNames;
return builder.Build();
}
public static ProducerSubmission WithProducerBusiness(ProducerBusiness producerBusiness)
{
var builder = new ProducerBuilder();
builder.producerBusiness = producerBusiness;
return builder.Build();
}
public static ProducerSubmission WithAuthorisedRepresentative(AuthorisedRepresentative authorisedRepresentative)
{
var builder = new ProducerBuilder();
builder.authorisedRepresentative = authorisedRepresentative;
return builder.Build();
}
public static ProducerSubmission WithEEEPlacedOnMarketBandType(EEEPlacedOnMarketBandType eeePlacedOnMarketBandType)
{
var builder = new ProducerBuilder();
builder.eeePlacedOnMarketBandType = eeePlacedOnMarketBandType;
return builder.Build();
}
public static ProducerSubmission WithSellingTechniqueType(SellingTechniqueType sellingTechniqueType)
{
var builder = new ProducerBuilder();
builder.sellingTechniqueType = sellingTechniqueType;
return builder.Build();
}
public static ProducerSubmission WithTradingName(string tradingName)
{
var builder = new ProducerBuilder();
builder.tradingName = tradingName;
return builder.Build();
}
public static ProducerSubmission WithAnnualTurnOverBandType(AnnualTurnOverBandType annualTurnOverBandType)
{
var builder = new ProducerBuilder();
builder.annualTurnOverBandType = annualTurnOverBandType;
return builder.Build();
}
