internal void OnInit(Connection connection, WidgetContext context, Widget widget)
{
ID = widget.ID;
Connection = connection;
Context = context;
object objConfig = widget.Config.ToObject(ConfigType) !;
widget.Config = StdJson.ObjectToJObject(objConfig);
SetConfig(objConfig);
Type type = GetType();
string prefix = RequestMethodNamePrefix;
int N = prefix.Length;
MethodInfo[] methods =
type.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)
.Where(m => m.Name.StartsWith(prefix))
.ToArray();
foreach (MethodInfo m in methods)
{
ParameterInfo[] parameters = m.GetParameters();
UIReqDelegate theDelegate = (object?[] args) => {
return((Task <ReqResult>)m.Invoke(this, args) !);
};
UiReqPara[] uiReqParameters = parameters.Select(MakeParameter).ToArray();
string key = m.Name.Substring(N);
mapUiReqMethods[key] = new UiReqMethod(theDelegate, uiReqParameters);
}
}
private void onEvent(Event evt)
{
switch (evt.Code)
{
case AdapterMsg.ID_Event_AlarmOrEvent:
var alarm = StdJson.ObjectFromUtf8Stream <AdapterAlarmOrEvent>(evt.Payload);
if (alarm != null)
{
callback?.Notify_AlarmOrEvent(alarm);
}
break;
case AdapterMsg.ID_Event_DataItemsChanged:
var items = StdJson.ObjectFromUtf8Stream <DataItemValue[]>(evt.Payload);
if (items != null)
{
callback?.Notify_DataItemsChanged(items);
}
break;
default:
Console.Error.WriteLine("Unknown event code: " + evt.Code);
break;
}
}
private static DataValue ConfigToIndentedDataValue(ViewConfig configuration)
{
string json = StdJson.ObjectToString(configuration, indented: true);
string c = "\r\n" + Indent(json, 8) + "\r\n ";
return(DataValue.FromJSON(c));
}
public async override void OnVariableHistoryChanged(HistoryChange[] changes)
{
var alarms = await GetActiveAlarms();
var events = await GetEvents(lastTimeRange, alarms);
var newOrChangedAlarms = alarms.Where(a => {
var oldVersion = lastAlarms.FirstOrDefault(x => x.T == a.T);
if (oldVersion == null)
{
return(true);
}
return(!StdJson.ObjectsDeepEqual(a, oldVersion));
}).ToArray();
var newOrChangedEvents = events.Where(a => {
var oldVersion = lastEvents.FirstOrDefault(x => x.T == a.T);
if (oldVersion == null)
{
return(true);
}
return(!StdJson.ObjectsDeepEqual(a, oldVersion));
}).ToArray();
if (newOrChangedAlarms.Length > 0 || newOrChangedEvents.Length > 0)
{
lastAlarms = alarms;
lastEvents = events;
Context.SendEventToUI("Event", new {
Alarms = newOrChangedAlarms,
Events = newOrChangedEvents
});
}
}
public override async Task <string[]> BrowseDataItemAddress(string?idOrNull)
{
if (!await TryConnect() || connection == null)
{
return(new string[0]);
}
var allObjects = await connection.GetAllObjects(moduleID);
var result = new List <string>();
foreach (ObjectInfo obj in allObjects)
{
foreach (Variable v in obj.Variables)
{
string objID = obj.ID.LocalObjectID;
string varName = v.Name;
if (varName == "Value")
{
result.Add(objID);
}
else
{
string[] objVar = new string[] { objID, varName };
result.Add(StdJson.ValueToString(objVar));
}
}
}
return(result.ToArray());
}
private static Page PageFromTab(View_HistoryPlots.TabConfig tab, View_HistoryPlots.DataExport dataExport)
{
var hc = new Widgets.HistoryPlotConfig()
{
PlotConfig = MapPlotConfig(tab.PlotConfig),
Items = tab.Items.Select(MapItemConfig).ToArray(),
DataExport = MapDataExport(dataExport)
};
JObject config = StdJson.ObjectToJObject(hc, indented: true);
return(new Page()
{
ID = tab.Name,
Name = tab.Name,
Rows = new Row[] {
new Row()
{
Columns = new Column[] {
new Column()
{
Width = ColumnWidth.Fill,
Widgets = new Widget[] {
new Widget("w1", "HistoryPlot", width: "100%", height: "600px", config: config)
}
}
}
}
}
});
}
public static ReqResult Bad(string errMsg)
{
string js = "{ \"error\": " + StdJson.ValueToString(errMsg) + "}";
byte[] bytes = Encoding.UTF8.GetBytes(js);
return(new ReqResult(400, new MemoryStream(bytes)));
}
private void SendEvent <T>(IList <T> values, byte eventID)
{
if (values == null || values.Count == 0)
{
return;
}
connector.SendEvent(eventID, s => StdJson.ObjectToStream(values, s));
}
private static async Task OnReceivedConfigWriteRequest(IMqttClient clientMQTT, LargePayloadReader reader, string moduleID, string topicBase, Connection clientFAST, MqttApplicationMessageReceivedEventArgs arg)
{
var msg = arg.ApplicationMessage;
await arg.AcknowledgeAsync(CancellationToken.None);
if (msg.Topic.EndsWith("/info"))
{
reader.SetInfo(msg.Payload);
string payload = Encoding.UTF8.GetString(msg.Payload);
Console.WriteLine($"Got Info msg! ClientID: {arg.ClientId}; Topic: {msg.Topic}; QOS: {msg.QualityOfServiceLevel}; Payload: {payload}");
}
else
{
int bucket = GetBucketNumberFromTopicName(msg.Topic);
reader.SetBucket(bucket, msg.Payload);
Console.WriteLine($"Got Data msg! ClientID: {arg.ClientId}; Topic: {msg.Topic}; Bucket: {bucket}; QOS: {msg.QualityOfServiceLevel}; Payload.Len: {msg.Payload.Length}");
}
string?content = reader.Content();
if (content != null)
{
try {
var nv = new NamedValue("config", content);
DataValue value = await clientFAST.CallMethod(moduleID, "SetConfigString", nv);
Console.WriteLine("Stored new config!");
}
catch (Exception exp) {
Exception e = exp.GetBaseException() ?? exp;
Console.Error.WriteLine($"Failed to set new config: {e.Message}");
byte[] payload = StdJson.ObjectToBytes(new {
Hash = reader.ContentHash,
Error = e.Message,
Time = Timestamp.Now.ToString()
}, indented: true);
var msgInfo = new MqttApplicationMessage()
{
QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce,
Retain = true,
Topic = $"{topicBase}/error",
PayloadFormatIndicator = MqttPayloadFormatIndicator.CharacterData,
Payload = payload,
};
await clientMQTT.PublishAsync(msgInfo);
}
}
}
private void SerializeArray <T>(T[] array, Stream output)
{
if (array == null || array.Length == 0)
{
output.WriteByte((byte)'[');
output.WriteByte((byte)']');
}
else
{
StdJson.ObjectToStream(array, output);
}
}
private static VariableRef MakeVarRefFromAddress(string address, string moduleID)
{
try {
string[]? arr = StdJson.ObjectFromString <string[]>(address);
if (arr != null && arr.Length == 2 && arr[0].Length > 0 && arr[1].Length > 0)
{
return(VariableRef.Make(moduleID, arr[0], arr[1]));
}
}
catch (Exception) {}
return(VariableRef.Make(moduleID, address, "Value"));
}
private async Task SendWebSocket(WebSocket socket, string msgStart, object content)
{
int pendingCounter = 0;
while (eventPending && !closed && pendingCounter < 100)
{
await Task.Delay(50);
pendingCounter += 1;
}
if (closed)
{
return;
}
try {
eventPending = true;
var stream = streamSend;
stream.Position = 0;
stream.SetLength(0);
// Console.WriteLine($"SendWebSocket: {stream.Capacity} Thread: {Thread.CurrentThread.ManagedThreadId}");
using (var writer = new StreamWriter(stream, UTF8_NoBOM, 1024, leaveOpen: true)) {
writer.Write(msgStart);
StdJson.ObjectToWriter(content, writer);
writer.Write("}");
}
ArraySegment <byte> segment;
stream.TryGetBuffer(out segment);
eventAcked = false;
await socket.SendAsync(segment, WebSocketMessageType.Text, true, CancellationToken.None);
int counter = 0;
while (!eventAcked && !closed && counter < 100)
{
await Task.Delay(50);
counter += 1;
}
}
catch (Exception exp) {
logInfo("SendWebSocket:", exp);
}
finally {
eventPending = false;
}
}
private async Task <T> SendRequest <T>(AdapterMsg requestMsg)
{
using (Response res = await connection.SendRequest(requestMsg.GetMessageCode(), stream => StdJson.ObjectToStream(requestMsg, stream))) {
if (res.Success)
{
return(StdJson.ObjectFromUtf8Stream <T>(res.SuccessPayload));
}
else
{
throw new Exception(res.ErrorMsg);
}
}
}
protected virtual string SerializeModelToString(T model)
{
switch (modelFormat)
{
case ModelFormat.XML:
return(Xml.ToXml(model));
case ModelFormat.JSON:
return(StdJson.ObjectToString(model, indented: true));
default:
throw new Exception($"Model format {modelFormat} not implemented in SerializeModelToString");
}
}
private async Task <VTQ> ReadDataItemFromDB(string itemID, string query, VTQ lastValue)
{
var rows = new List <JObject>();
using (DbCommand cmd = CreateCommand(dbConnection !, query)) {
using (var reader = await cmd.ExecuteReaderAsync()) {
while (reader.Read())
{
int n = reader.FieldCount;
JObject objRow = new JObject();
for (int i = 0; i < n; ++i)
{
string name = reader.GetName(i);
object value = reader.GetValue(i);
objRow[name] = JToken.FromObject(value);
}
rows.Add(objRow);
}
}
}
DataValue dataValue = DataValue.FromObject(rows, indented: true);
if (lastValue.V == dataValue)
{
return(lastValue);
}
VTQ vtq = VTQ.Make(dataValue, Timestamp.Now.TruncateMilliseconds(), Quality.Good);
int N = rows.Count;
string firstRow = N == 0 ? "" : StdJson.ObjectToString(rows[0], indented: false);
if (N == 0)
{
PrintLine($"Read 0 rows for {itemID}");
}
else if (N == 1)
{
PrintLine($"Read 1 row for {itemID}: {firstRow}");
}
else
{
PrintLine($"Read {N} rows for {itemID}. First row: {firstRow}");
}
return(vtq);
}
internal async Task SaveWidgetConfiguration(string pageID, Widget widget, object newWidgetConfig)
{
JObject objNewWidgetConfig = StdJson.ObjectToJObject(newWidgetConfig);
widget.Config = objNewWidgetConfig;
DataValue newViewConfig = DataValue.FromObject(configuration, indented: true);
await Context.SaveViewConfiguration(newViewConfig);
var msg = new {
PageID = pageID,
WidgetID = widget.ID,
Config = widget.Config,
};
await Context.SendEventToUI("WidgetConfigChanged", msg);
}
private async Task <List <ObjectMember> > GetObjectMembers(string id, string type)
{
ObjectRef obj = ObjectRef.FromEncodedString(id);
ClassInfo info = objTypes[type];
MemberRef[] members = info.SimpleMember.Select(m => MemberRef.Make(obj, m.Name)).ToArray();
MemberValue[] memValues = await Connection.GetMemberValues(members);
var values = new List <ObjectMember>();
for (int i = 0; i < info.SimpleMember.Count; ++i)
{
SimpleMember m = info.SimpleMember[i];
MemberValue v = memValues[i];
string defaultValue = "";
if (m.DefaultValue.HasValue && m.Dimension != Dimension.Array)
{
defaultValue = m.DefaultValue.Value.JSON;
}
else if (m.Type == DataType.Struct)
{
defaultValue = StdJson.ObjectToString(GetStructDefaultValue(m), indented: true, ignoreNullValues: false);
//Console.WriteLine("=> " + m.Name + ": " + defaultValue);
}
else
{
defaultValue = DataValue.FromDataType(m.Type, 1).JSON;
}
var member = new ObjectMember()
{
Key = obj.ToEncodedString() + "__" + m.Name,
Name = m.Name,
Type = m.Type.ToString(),
IsScalar = m.Dimension == Dimension.Scalar,
IsOption = m.Dimension == Dimension.Optional,
IsArray = m.Dimension == Dimension.Array,
Category = m.Category,
Browseable = m.Browseable,
Value = new JRaw(v.Value.JSON),
ValueOriginal = new JRaw(v.Value.JSON),
EnumValues = ResolveEnum(m),
StructMembers = ResolveStruct(m),
DefaultValue = defaultValue
};
values.Add(member);
}
return(values);
}
protected virtual T DeserializeModelFromString(string model)
{
string m = model.TrimStart();
if (m.StartsWith("<"))
{
modelFormat = ModelFormat.XML;
return(Xml.FromXmlString <T>(model));
}
else if (m.StartsWith("{"))
{
modelFormat = ModelFormat.JSON;
return(StdJson.ObjectFromString <T>(model) ?? new T());
}
else
{
throw new Exception($"Unknown file format for {modelFileName}: expected XML or JSON");
}
}
public static ReqResult OK(object obj)
{
if (typeof(Task).IsAssignableFrom(obj.GetType()))
{
throw new Exception("ReqResult.OK: obj may not be a Task!");
}
var res = MemoryManager.GetMemoryStream("ReqResult.OK");
try {
StdJson.ObjectToStream(obj, res, indented: true, ignoreNullValues: false);
res.Seek(0, SeekOrigin.Begin);
}
catch (Exception) {
res.Dispose();
throw;
}
return(new ReqResult(200, res));
}
private async Task SendWebSocket(WebSocket socket, string msgStart, object content)
{
try {
using (var stream = MemoryManager.GetMemoryStream("Session.SendWebSocket")) {
using (var writer = new StreamWriter(stream, UTF8_NoBOM, 1024, leaveOpen: true)) {
writer.Write(msgStart);
StdJson.ObjectToWriter(content, writer);
writer.Write("}");
}
byte[] bytes = stream.GetBuffer();
int count = (int)stream.Length;
var segment = new ArraySegment <byte>(bytes, 0, count);
await socket.SendAsync(segment, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
catch (Exception exp) {
logInfo("SendWebSocket:", exp);
}
}
public static ReqResult OK(object obj, bool ignoreShouldSerializeMembers = false, string?contentType = null)
{
if (typeof(Task).IsAssignableFrom(obj.GetType()))
{
throw new Exception("ReqResult.OK: obj may not be a Task!");
}
var res = MemoryManager.GetMemoryStream("ReqResult.OK");
try {
StdJson.ObjectToStream(obj, res, indented: true, ignoreShouldSerializeMembers: ignoreShouldSerializeMembers);
res.Seek(0, SeekOrigin.Begin);
}
catch (Exception) {
res.Dispose();
throw;
}
return(new ReqResult(200, res, contentType: contentType));
}
public override async Task <BrowseDataItemsResult> BrowseDataItems()
{
if (connection == null)
{
string endpoint = config?.Address ?? "";
string msg = $"No connection to server '{endpoint}': " + lastConnectErrMsg;
return(new BrowseDataItemsResult(
supportsBrowsing: true,
browsingError: msg,
items: new DataItemBrowseInfo[0],
clientCertificate: ""));
}
var allObjects = await connection.GetAllObjects(moduleID);
var result = new List <DataItemBrowseInfo>();
foreach (ObjectInfo obj in allObjects)
{
foreach (Variable v in obj.Variables)
{
string objID = obj.ID.LocalObjectID;
string varName = v.Name;
if (varName == "Value")
{
result.Add(new DataItemBrowseInfo(objID, new[] { objID }));
}
else
{
string[] objVar = new string[] { objID, varName };
string id = StdJson.ValueToString(objVar);
result.Add(new DataItemBrowseInfo(id, objVar));
}
}
}
return(new BrowseDataItemsResult(
supportsBrowsing: true,
browsingError: "",
items: result.ToArray(),
clientCertificate: ""));
}
private static async Task Loop(TcpConnectorSlave connector, AdapterBase module)
{
Process?parentProcess = null;
using (Request request = await connector.ReceiveRequest(5000)) {
if (request.Code != AdapterMsg.ID_ParentInfo)
{
throw new Exception("Missing ParentInfo request");
}
ParentInfoMsg?info = StdJson.ObjectFromUtf8Stream <ParentInfoMsg>(request.Payload);
if (info == null)
{
throw new Exception("ParentInfoMsg is null");
}
parentProcess = Process.GetProcessById(info.PID);
connector.SendResponseSuccess(request.RequestID, s => { });
}
Thread t = new Thread(() => { ParentAliveChecker(parentProcess); });
t.IsBackground = true;
t.Start();
var helper = new AdapterHelper(module, connector);
bool run = true;
while (run)
{
using (Request request = await connector.ReceiveRequest()) {
helper.ExecuteAdapterRequestAsync(request);
bool shutdown = request.Code == AdapterMsg.ID_Shutdown;
run = !shutdown;
}
}
// Wait until parent process kills us (after Shutdown method completed)
while (true)
{
await Task.Delay(1000);
}
}
public async Task <ReqResult> UiReq_ConfigPageDuplicate(string pageID, string newPageID, string title)
{
CheckActivePage(pageID);
string pageCopy = StdJson.ObjectToString(activePage !.Page);
var page = StdJson.ObjectFromString <Page>(pageCopy) !;
page.ID = newPageID;
page.Name = title;
var pages = configuration.Pages.ToList();
pages.Add(page);
configuration.Pages = pages.ToArray();
Pages[page.ID] = new PageState(page, Connection, widgetTypes, this);
DataValue newViewConfig = DataValue.FromObject(configuration, indented: true);
await Context.SaveViewConfiguration(newViewConfig);
return(ReqResult.OK(configuration.Pages));
}
public async Task Register(IMqttClient clientMQTT, VariableValues allValues)
{
if (topic == "")
{
return;
}
var newVarVals = allValues.Where(v => !registeredVars.Contains(v.Variable)).ToList();
while (newVarVals.Count > 0)
{
int BatchSize = Math.Min(varPub.PayloadLimit, newVarVals.Count);
var batch = newVarVals.Take(BatchSize).ToArray();
newVarVals.RemoveRange(0, BatchSize);
JObject[] payload = batch.Select(vv => FromVariableValue(vv, varPub)).ToArray();
string msg = StdJson.ObjectToString(payload);
try {
await clientMQTT.PublishAsync(topic, msg);
foreach (var vv in batch)
{
registeredVars.Add(vv.Variable);
}
if (varPub.PrintPayload)
{
Console.Out.WriteLine($"REG PUB: {topic}: {msg}");
}
}
catch (Exception exp) {
Exception e = exp.GetBaseException() ?? exp;
Console.Error.WriteLine($"Reg Publish failed for topic {topic}: {e.Message}");
break;
}
}
}
public async override Task OnVariableHistoryChanged(List <HistoryChange> changes)
{
var alarms = await GetActiveAlarms();
var events = await GetEvents(lastTimeRange, alarms);
var newOrChangedAlarms = alarms.Where(a => {
var oldVersion = lastAlarms.FirstOrDefault(x => x.T == a.T);
if (oldVersion == null)
{
return(true);
}
return(!StdJson.ObjectsDeepEqual(a, oldVersion));
}).ToArray();
long[] removedAlarms = lastAlarms.Where(la => alarms.All(a => a.T != la.T)).Select(x => x.T).ToArray();
var newOrChangedEvents = events.Where(a => {
var oldVersion = lastEvents.FirstOrDefault(x => x.T == a.T);
if (oldVersion == null)
{
return(true);
}
return(!StdJson.ObjectsDeepEqual(a, oldVersion));
}).ToArray();
if (newOrChangedAlarms.Length > 0 || newOrChangedEvents.Length > 0 || removedAlarms.Length > 0)
{
lastAlarms = alarms;
lastEvents = events;
await Context.SendEventToUI("Event", new {
Alarms = newOrChangedAlarms,
Events = newOrChangedEvents,
RemovedAlarms = removedAlarms,
});
}
}
public virtual async Task <ReqResult> OnUiRequestAsync(string command, DataValue parameters)
{
if (mapUiReqMethods.ContainsKey(command))
{
UiReqMethod method = mapUiReqMethods[command];
method.ResetValues();
JObject obj = StdJson.JObjectFromString(parameters.JSON);
foreach (JProperty p in obj.Properties())
{
if (method.ParameterMap.ContainsKey(p.Name))
{
UiReqPara para = method.ParameterMap[p.Name];
para.Value = p.Value.ToObject(para.Type);
}
}
object?[] paramValues = method.Parameters.Select(p => p.Value).ToArray();
return(await method.TheDelegate(paramValues));
}
return(ReqResult.Bad("Unknown command: " + command));
}
private async Task SendVoidRequest(AdapterMsg requestMsg)
{
if (connection == null)
{
return;
}
using (Response res = await connection.SendRequest(requestMsg.GetMessageCode(), stream => StdJson.ObjectToStream(requestMsg, stream))) {
if (res.Success)
{
return;
}
else
{
throw new Exception(res.ErrorMsg);
}
}
}
private async Task <T> SendRequest <T>(AdapterMsg requestMsg)
{
if (connection == null)
{
throw new Exception("ExternalAdapter.SendRequest: connection is null");
}
using (Response res = await connection.SendRequest(requestMsg.GetMessageCode(), stream => StdJson.ObjectToStream(requestMsg, stream))) {
if (res.Success)
{
return(StdJson.ObjectFromUtf8Stream <T>(res.SuccessPayload !) ?? throw new Exception($"ExternalAdapter.SendRequest {requestMsg.GetType().Name}: returned result is null"));
}
else
{
throw new Exception(res.ErrorMsg);
}
}
}
public void Notify_AlarmOrEvent(AdapterAlarmOrEvent eventInfo)
{
connector.SendEvent(AdapterMsg.ID_Event_AlarmOrEvent, s => StdJson.ObjectToStream(eventInfo, s));
}
