/// <summary>
/// Copy Constructor
/// </summary>
/// <param name="other"></param>
/// <param name="parent"></param>
/// <returns>InitializeConnection</returns>
public InitializeConnection(InitializeConnection other, BaseAggregate parent)
: base(other, parent)
{
DeviceId = new BaseField <string>(other.DeviceId, this);
PushFields();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
BaseAggregate.SetLogger(BCTLoggerService.GetLogger <BaseAggregate>());
await host.RunAsync();
}
private static Task OnMessageReceived(MqttApplicationMessageReceivedEventArgs arg)
{
var messageTypeString = arg.ApplicationMessage
.UserProperties?
.FirstOrDefault(p => p.Name == "messageType")?
.Value;
var payloadType = arg.ApplicationMessage
.UserProperties?
.FirstOrDefault(p => p.Name == "payloadType")?
.Value;
Console.WriteLine(messageTypeString);
switch (messageTypeString)
{
case "ConnectionAccepted":
if (payloadType == nameof(InitializeConnectionResponse))
{
var agg = BaseAggregate.Deserialize <InitializeConnectionResponse>(Encoding.UTF8.GetString(arg.ApplicationMessage.Payload));
if (_correlation.SequenceEqual(arg.ApplicationMessage.CorrelationData))
{
Console.WriteLine($"MessageType:{messageTypeString} RequestApproved:{agg.RequestApproved.Value} Correlation matches");
}
else
{
Console.WriteLine("Correlation data mismatched");
}
}
break;
default:
break;
}
return(Task.CompletedTask);
}
/// <summary>
/// Copy Constructor
/// </summary>
/// <param name="other"></param>
/// <param name="parent"></param>
/// <returns>InitializeConnectionResponse</returns>
public InitializeConnectionResponse(InitializeConnectionResponse other, BaseAggregate parent)
: base(other, parent)
{
DeviceId = new BaseField <string>(other.DeviceId, this);
RequestApproved = new BaseField <bool>(other.RequestApproved, this);
PushFields();
}
/// <summary>
/// Copy Constructor
/// </summary>
/// <param name="other"></param>
/// <param name="parent"></param>
/// <returns>DeviceStatus</returns>
public DeviceStatus(DeviceStatus other, BaseAggregate parent)
: base(other, parent)
{
DeviceId = new BaseField <string>(other.DeviceId, this);
MessageId = new BaseField <string>(other.MessageId, this);
When = new BaseField <double>(other.When, this);
Condition = new EnumField <StatusEnum>(other.Condition, this);
PushFields();
}
public InboundRequest()
{
PropertyBag = new Dictionary <string, object>();
_lazyMessage = new Lazy <T>(() =>
{
var json = Encoding.UTF8.GetString(RawMessage.Payload);
var obj = BaseAggregate.Deserialize <T>(json);
return(obj);
});
}
public async Task Commit(BaseAggregate aggregate, CancellationToken cancellationToken)
{
using (var evtStream = _eventStore.OpenStream(aggregate.AggregateId))
{
foreach (var domainEvent in aggregate.DomainEvents)
{
evtStream.Add(new EventMessage {
Body = domainEvent
});
}
evtStream.CommitChanges(Guid.NewGuid());
}
await Commit(aggregate.DomainEvents, cancellationToken);
}
/// <summary>
/// Constructor
/// </summary>
public DeviceStatus(int fieldId, BaseAggregate parent)
: base(fieldId, parent) => Initialize();
/// <summary>
/// Deserializes the given JSON string into an instance of this aggregate.
/// </summary>
/// <param name="json"></param>
/// <returns></returns>
static public DeviceStatus Deserialize(string json)
{
return(BaseAggregate.Deserialize <DeviceStatus>(json));
}
/// <summary>
/// Serializes this aggregate to JSON string.
/// </summary>
/// <returns></returns>
public string Serialize()
{
return(BaseAggregate.Serialize(this));
}
static async Task Main(string[] args)
{
// TODO refactor into proper app with DI
var settingsConfiguration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
settingsConfiguration.ConfigureBCTLogging();
var serviceCollection = new ServiceCollection();
serviceCollection.AddLogging(configure => configure.AddBCTLogging());
serviceCollection.Configure <LoggerFilterOptions>(options => options.MinLevel = LogLevel.Trace);
IServiceProvider m_serviceProvider = serviceCollection.BuildServiceProvider();
var logger = m_serviceProvider.GetService <ILogger <BaseAggregate> >();
BaseAggregate.SetLogger(logger);
logger.WithInformation("Logging initialized").Log();
logger.WithError("error").Log();
var running = true;
var are = new AutoResetEvent(false);
Console.CancelKeyPress += (sender, eventArgs) =>
{
running = false;
eventArgs.Cancel = true;
are.Set();
};
var deviceType = "device-type-1";
var deviceUniqueId = Guid.NewGuid();
//var deviceUniqueId = "a";
var deviceId = $"{deviceType}-{deviceUniqueId}";
Console.Title = $"Device: {deviceId}";
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithPendingMessagesOverflowStrategy(MqttPendingMessagesOverflowStrategy.DropOldestQueuedMessage)
.WithClientOptions(new MqttClientOptionsBuilder()
.WithCommunicationTimeout(TimeSpan.FromSeconds(15))
.WithProtocolVersion(MqttProtocolVersion.V500)
.WithClientId(deviceId)
.WithTcpServer("192.168.1.98", 1883)
//.WithTls()
.Build()
)
.Build();
using (var cancellationTokenSource = new CancellationTokenSource())
using (var mqttClient = new MqttFactory().CreateManagedMqttClient())
{
await mqttClient.SubscribeAsync(
new TopicFilterBuilder().WithTopic("bct/app/status").Build(),
new TopicFilterBuilder().WithTopic($"bct/{deviceType}/{deviceId}/response").Build(),
new TopicFilterBuilder().WithTopic($"bct/{deviceType}/{deviceId}/in").Build());
mqttClient.ApplicationMessageReceivedHandler =
new MqttApplicationMessageReceivedHandlerDelegate(OnMessageReceived);
await mqttClient.StartAsync(options);
var initializeMessage = new InitializeConnection();
initializeMessage.DeviceId.Value = deviceId;
var payload = Encoding.UTF8.GetBytes(initializeMessage.Serialize());
_correlation = Guid.NewGuid().ToByteArray();
await mqttClient.PublishAsync(builder =>
builder
.WithTopic($"bct/{deviceType}/{deviceId}/out")
.WithResponseTopic($"bct/{deviceType}/{deviceId}/response")
.WithCorrelationData(_correlation)
.WithUserProperty("messageType", nameof(InitializeConnection))
.WithUserProperty("responseType", nameof(InitializeConnectionResponse))
.WithPayload(payload)
, cancellationTokenSource.Token);
Console.WriteLine($"Publishing InitializeConnection Message");
await Task.Run(async() =>
{
while (running)
{
var messageId = Guid.NewGuid();
var devStatus = new DeviceStatus();
devStatus.Condition.Value = StatusEnum.Connected;
devStatus.DeviceId.Value = deviceId;
devStatus.MessageId.Value = messageId.ToString();
devStatus.When.Value = Convert.ToDouble(DateTime.UtcNow.Ticks);
var payload = Encoding.UTF8.GetBytes(devStatus.Serialize());
await mqttClient.PublishAsync(builder =>
builder
.WithTopic($"bct/{deviceType}/{deviceId}/status")
// KWC HOW IS THIS DIFFERENT .WithMessage<DeviceStatus>(devStatus)
.WithUserProperty("messageType", nameof(DeviceStatus))
.WithPayload(payload)
.WithContentType("application/json")
, cancellationTokenSource.Token);
await Task.Delay(5000, cancellationTokenSource.Token);
}
}, cancellationTokenSource.Token);
are.WaitOne();
await mqttClient.StopAsync();
}
}
/// <summary>
/// Constructor
/// </summary>
public InitializeConnectionResponse(int fieldId, BaseAggregate parent)
: base(fieldId, parent) => Initialize();
/// <summary>
/// Deserializes the given JSON string into an instance of this aggregate.
/// </summary>
/// <param name="json"></param>
/// <returns></returns>
static public InitializeConnectionResponse Deserialize(string json)
{
return(BaseAggregate.Deserialize <InitializeConnectionResponse>(json));
}
