/// <summary>
/// Show A Finsemble Component.
/// </summary>
/// <param name="windowIdentifier">A JObject containing a windowName, uuid and componentType</param>
/// <param name="parameters"></param>
/// <param name="callback"></param>
public void ShowWindow(JObject windowIdentifier, JObject parameters, EventHandler <FinsembleEventArgs> callback)
{
parameters["windowIdentifier"] = windowIdentifier;
parameters["relativeWindow"] = windowClient.windowIdentifier;
routerClient.Query("Launcher.showWindow", parameters, new JObject {
}, callback);
}
/// <summary>
/// parameters is a JObject containing the field
/// callback is called with the value
/// </summary>
/// <example>
/// <code>
/// bridge.configClient.GetValue(new JObject {["field"] = "fieldname"}, (sender, args) => {
/// var fieldValue = args.response
/// })
/// </code>
/// </example>
/// <param name="parameters"></param>
/// <param name="callback"></param>
public void GetValue(JObject parameters, EventHandler <FinsembleEventArgs> callback)
{
routerClient.Query("configService.getValue", new JObject
{
["field"] = parameters["field"]
}, new JObject {
}, callback);
}
/// <summary>
/// Sets a value in a distributed store.
/// </summary>
/// <example>
/// <code>
/// store.SetValue(new JObject{["field"] = "field1", ["value"] = "new value"}, (sender, args) => {
/// // value was set in store. Nothing needs to be done here.
/// });
/// </code>
/// </example>
/// <param name="parameters"></param>
/// <param name="callback"></param>
public void SetValue(JObject parameters, EventHandler <FinsembleEventArgs> callback)
{
var data = new JObject
{
["store"] = name,
["field"] = (string)parameters["field"],
["value"] = parameters["value"]
};
routerClient.Query("storeService.setValue", data, new JObject {
}, callback);
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
// TODO: dispose managed state (managed objects).
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
try
{
// Unregister logger.
JObject parameters = new JObject
{
["clientName"] = bridge.windowName
};
routerClient.Query("logger.service.unregister", parameters, new JObject {
}, (s, a) => { });
}
catch
{
// TODO: Log error
}
disposedValue = true;
}
}
/// <summary>
/// Returns the current global credentials (as published through PublishAuthorization}) or null if no credentials are set yet.
/// </summary>
/// <param name="callback">A function that returns the current credentials. Will return null if no credentials have yet been established.</param>
public void GetCurrentCredentials <T>(EventHandler <T> callback)
{
routerClient.Query("authentication.currentCredentials", new JObject {
}, new JObject {
}, (sender, args) => {
var jCredentials = args.response?["data"];
T credentials = jCredentials.ToObject <T>();
callback(sender, credentials);
});
}
public Logger(Finsemble bridge)
{
routerClient = bridge.RouterClient;
this.bridge = bridge;
routerClient.Query("logger.service.register", new JObject
{
["clientName"] = bridge.windowName,
["clientChannel"] = "finsemble.logger.client." + bridge.windowName,
["uuid"] = bridge.uuid,
["windowName"] = bridge.windowName
}, new JObject {
}, (s, a) => { });
}
private void Maxmimize()
{
Application.Current.Dispatcher.Invoke(delegate //main thread
{
//dockingWindow.WindowState = WindowState.Maximized;
dynamic props = new ExpandoObject();
props.windowName = dockingWindowName;
props.windowAction = "maximize";
/*DH 07/22/19
* We have found that WPF windows are not maximized via the normal
* system event, and thus the maximize event isn't detected by Assimilation.
* Therefore, we must inform the Window Service ourselves, using the same
* message that AssimilationService does.*/
routerClient.Query("WindowService-Request-maximize",
new JObject {
["fromAssimilation"] = true,
["windowIdentifier"] = new JObject {
["name"] = dockingWindowName
}
},
(sender, args) => { });
});
}
private void Scrim_PreviewDrop(object sender, DragEventArgs e)
{
var jsonData = JObject.Parse(e.Data.GetData(DataFormats.StringFormat).ToString());
if (jsonData["containsData"] == null)
{
routerClient.Query(jsonData["window"] + ".Share", jsonData["emitters"], new JObject {
}, (s, args) => {
HandleSharedData(args.response?["data"] as JObject, ShareMethod.Drop);
});
}
else
{
HandleSharedData(jsonData["data"] as JObject, ShareMethod.Drop);
}
e.Handled = true;
}
/// <summary>
/// Shows the Finsemble Linker Window
/// </summary>
/// <param name="left">Left of Linker Window relative to the current window (default 0)</param>
/// <param name="top">Top of Linker Window relative to the current window (default 30)</param>
public void ShowLinkerWindow(double left = 0, double top = 30)
{
var channelsToSend = new JArray {
};
if (channels != null)
{
foreach (var item in channels)
{
var channelinfo = allChannels.Where(jt => jt["name"].ToString() == item.ToString())?.First();
if (channelinfo != null)
{
channelsToSend.Add(channelinfo);
}
}
}
JObject data = new JObject
{
["channels"] = channelsToSend,
["windowIdentifier"] = windowClient.windowIdentifier
};
routerClient.Query("Finsemble.LinkerWindow.SetActiveChannels", data, new JObject {
}, delegate(object sender, FinsembleEventArgs e)
{
Application.Current.Dispatcher.Invoke((Action) delegate //main thread
{
var wi = new JObject
{
["componentType"] = "linkerWindow"
};
var parameters = new JObject
{
["position"] = "relative",
["left"] = left,
["top"] = top,
["spawnIfNotFound"] = false
};
launcherClient.ShowWindow(wi, parameters, (EventHandler <FinsembleEventArgs>) delegate(object s2, FinsembleEventArgs e2) { });
});
});
}
/// <summary>
/// Get a value from storage.
/// </summary>
/// <param name="parameters"></param>
/// <param name="callback"></param>
public void Get(JObject parameters, EventHandler <FinsembleEventArgs> callback)
{
routerClient.Query("Storage.get", parameters, new JObject {
}, callback);
}
private void RPC(string endpoint, List <JToken> args, EventHandler <FinsembleEventArgs> cb)
{
switch (endpoint)
{
case "RouterClient.transmit":
RouterClient.Transmit((string)args[0], args[1]);
break;
case "RouterClient.addListener":
RouterClient.AddListener((string)args[0], cb);
break;
case "RouterClient.removeListener":
RouterClient.RemoveListener((string)args[0], cb);
break;
case "RouterClient.publish":
RouterClient.Publish((string)args[0], args[1]);
break;
case "RouterClient.subscribe":
RouterClient.Subscribe((string)args[0], cb);
break;
case "RouterClient.unsubscribe":
RouterClient.Unsubscribe((string)args[0], cb);
break;
case "RouterClient.query":
RouterClient.Query((string)args[0], args[1], args[2] as JObject, cb);
break;
case "LinkerClient.publish":
LinkerClient.Publish(args[0] as JObject);
break;
case "LinkerClient.subscribe":
LinkerClient.Subscribe((string)args[0], cb);
break;
case "LauncherClient.spawn":
LauncherClient.Spawn((string)args[0], args[1] as JObject, cb);
break;
case "LauncherClient.showWindow":
LauncherClient.ShowWindow(args[0] as JObject, args[1] as JObject, cb);
break;
case "ConfigClient.getValue":
ConfigClient.GetValue(args[0] as JObject, cb);
break;
case "AuthenticationClient.publishAuthorization":
authenticationClient.PublishAuthorization <JObject>((string)args[0], args[1] as JObject);
break;
case "AuthenticationClient.getCurrentCredentials":
authenticationClient.GetCurrentCredentials <JObject>((s, a) =>
{
cb(this, new FinsembleEventArgs(null, a));
});
break;
case "Logger.error":
JToken[] argsArray = args.ToArray();
logger.Error(argsArray);
break;
case "Logger.warn":
logger.Warn(args.ToArray());
break;
case "Logger.log":
logger.Log(args.ToArray());
break;
case "Logger.info":
logger.Info(args.ToArray());
break;
case "Logger.debug":
logger.Debug(args.ToArray());
break;
case "Logger.verbose":
logger.Verbose(args.ToArray());
break;
default:
throw new Exception("This API does not exist or is not yet supported");
}
}
