public IDisposable Subscribe(IObserver <T> observer)
{
try
{
AbstractResponse response = this.connect();
CancellationDisposable cd = new CancellationDisposable();
IDisposable cancel = this.scheduler.Schedule(() =>
{
try
{
XmlNode next = response.NextNode();
while (next != null && !cd.IsDisposed)
{
observer.OnNext((T)XmlReadWrite.CreateFromXml(typeof(T), next));
next = response.NextNode();
}
observer.OnCompleted();
}
catch (Exception e)
{
Log.LogException(e);
observer.OnError(e);
}
});
return(new CompositeDisposable(cd, cancel, response));
}
catch (Exception e)
{
Log.LogException(e);
observer.OnError(e);
}
return(Disposable.Empty);
}
protected override AbstractResponse DoCommunication(XmlNode request)
{
try
{
HttpWebRequest httpReq = this.authentication.GetHttpRequest(this.uri, request != null);
if (request != null)
{
Stream reqStream = httpReq.GetRequestStream();
XmlReadWrite.WriteToStream(true, request, reqStream);
HttpWebResponse httpResp = (HttpWebResponse)httpReq.GetResponse();
if (httpResp.StatusCode < HttpStatusCode.BadRequest)
{
return(new HttpResponse(httpResp));
}
else
{
throw new AdvanceIOException(string.Format("Response with {0} ({1}) Http status code", httpResp.StatusCode.ToString(), (int)httpResp.StatusCode));
}
}
else
{
throw new AdvanceIOException("Request generation failed");
}
}
catch (Exception e)
{
throw new AdvanceIOException(this.uri + " communication failed", e);
}
}
/// <summary>
/// Updates notification groups
/// </summary>
/// <remarks>
/// Note that this update is considered complete, e.g., the existing group
/// settings will be deleted and replaced by the contents of the map.
/// </remarks>
/// <param name="groups">notification group names with set of notification address by notification group types</param>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceXMLException">On Xml parsing error</exception>
/// <exception cref="AdvanceControlException">if username or password is incorrect</exception>
public void UpdateNotificationGroups(Dictionary <AdvanceNotificationGroupType, Dictionary <string, ICollection <string> > > groups)
{
XmlDocument req = XmlReadWrite.CreateFunctionRequest("update-notification-groups");
AdvanceNotificationGroup.FillXmlElementFromDict(req.DocumentElement, groups);
this.communicator.Send(req);
}
/// <summary>
/// Update flow descriptor in the given realm.
/// </summary>
/// <param name="realm">target realm</param>
/// <param name="flow">flow descriptor XML</param>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceXMLException">On Xml parsing error</exception>
/// <exception cref="AdvanceControlException">if username or password is incorrect</exception>
public void UpdateFlow(string realm, XmlNode flow)
{
XmlDocument req = XmlReadWrite.CreateFunctionRequest("update-flow", "realm", realm);
req.DocumentElement.AppendChild(req.ImportNode(flow, true));
this.communicator.Send(req);
}
/// <summary>
/// Creates new realm.
/// </summary>
/// <param name="realm">realm name</param>
/// <param name="byUser">user who creates the object</param>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceXMLException">On Xml parsing error</exception>
/// <exception cref="AdvanceControlException">if username or password is incorrect</exception>
public void CreateRealm(string realm, string byUser)
{
Dictionary <string, object> attrs = new Dictionary <string, object>();
attrs.Add("realm", realm);
attrs.Add("by-user", byUser);
this.communicator.Send(XmlReadWrite.CreateFunctionRequest("update-realm", null, attrs));
}
public XmlParsedInformation readDataStorageXml(string fileName)
{
//get the xml-file from the xmlreadWrite class.
XmlDocument doc = XmlReadWrite.getInstance( ).readXmlDocument(fileName);
XmlParsedInformation rootNode = XmlReadWrite.getInstance( ).parseXmlDocument(doc);
return(rootNode);
}
/// <summary>
/// Delete a key entry from a keystore.
/// </summary>
/// <param name="keyStore">key store name</param>
/// <param name="keyAlias">key alias</param>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceControlException">if user is not allowed to delete key.</exception>
public void DeleteKeyEntry(string keyStore, string keyAlias)
{
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters.Add("keystore", keyStore);
parameters.Add("keyalias", keyAlias);
this.communicator.Send(XmlReadWrite.CreateFunctionRequest("delete-key-entry", null, parameters));
}
/// <summary>
/// gets a singleton instance of this class.
/// </summary>
/// <returns></returns>
public static XmlReadWrite getInstance( )
{
if (_instance == null)
{
_instance = new XmlReadWrite( );
}
return(_instance);
}
/// <summary>
/// Import a private key into a designated key store.
/// </summary>
/// <param name="request">represents the key store and key alias to import</param>
/// <param name="data">ckey in textual PEM format.</param>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceControlException">if user is not allowed to export.</exception>
public void ImportPrivateKey(AdvanceKeyStoreExport request, string keyData, string certData)
{
XmlDocument req = XmlReadWrite.CreateFunctionRequest("import-private-key", request);
XmlReadWrite.AddTextNode(req.DocumentElement, "private-key", keyData);
XmlReadWrite.AddTextNode(req.DocumentElement, "certificate", certData);
this.communicator.Send(req);
}
/// <summary>
/// Ask for the observable sequence of block diagnostic messages for the given block
/// within the given realm.
/// </summary>
/// <param name="realm">realm</param>
/// <param name="blockId">block unique identifier (as in the flow)</param>
/// <returns>observable for the diagnostic messages</returns>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceXMLException">On Xml parsing error</exception>
/// <exception cref="AdvanceControlException">if user is not allowed to update a flow.</exception>
public IObservable <BlockDiagnostic> DebugBlock(string realm, string blockId)
{
Dictionary <string, object> attrs = new Dictionary <string, object>();
attrs.Add("realm", realm);
attrs.Add("port-id", blockId);
return(this.communicator.Receive <BlockDiagnostic>(XmlReadWrite.CreateFunctionRequest("debug-block", null, attrs), new NewThreadScheduler()));
}
/// <summary>
/// Start a realm's execution.
/// </summary>
/// <param name="name">realm's name</param>
/// <param name="byUser">user who is starting the realm</param>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceControlException">if user is not allowed to start the realm or other problems arise.</exception>
public void StartRealm(string name, string byUser)
{
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters.Add("name", name);
parameters.Add("by-user", byUser);
this.communicator.Send(XmlReadWrite.CreateFunctionRequest("start-realm", null, parameters));
}
/// <summary>
/// Query block state.
/// </summary>
/// <param name="realm">realm name</param>
/// <param name="blockId"> block identifier</param>
/// <returns>Flow descriptor xml element</returns>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceXMLException">On Xml parsing error</exception>
/// <exception cref="AdvanceControlException">if username or password is incorrect</exception>
public XmlNode QueryBlockState(string realm, string blockId)
{
Dictionary <string, object> attrs = new Dictionary <string, object>();
attrs.Add("realm", realm);
attrs.Add("block-id", blockId);
return(this.communicator.Query(XmlReadWrite.CreateFunctionRequest("query-block-state", null, attrs)));
}
public XmlNode NextNode()
{
if (this.xmlReader == null)
{
this.xmlReader = XmlReader.Create(this.GetResponseStream());
}
return(XmlReadWrite.ReadFregment(this.xmlReader));
}
/// <summary>
/// Enable/disable a user.
/// </summary>
/// <param name="userName">User's identifier</param>
/// <param name="enabled">if true enable otherwise disable</param>
/// <param name="byUser">user who is changes it</param>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceControlException">if username or password is incorrect</exception>
public void EnableUser(string userName, bool enabled, string byUser)
{
Dictionary <string, object> attrs = new Dictionary <string, object>();
attrs.Add("user-name", userName);
attrs.Add("enabled", enabled);
attrs.Add("by-user", byUser);
this.communicator.Send(XmlReadWrite.CreateFunctionRequest("enable-user", null, attrs));
}
/// <summary>
/// Ask for the observable sequence of port messages of the given port/block/realm.
/// </summary>
/// <param name="realm">realm</param>
/// <param name="blockId">block unique identifier (as in the flow)</param>
/// <param name="port">port name</param>
/// <returns>observable of parameter messages</returns>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceXMLException">On Xml parsing error</exception>
/// <exception cref="AdvanceControlException">if user is not allowed to debug in the realm or referenced parameter is missing.</exception>
public IObservable <PortDiagnostic> DebugParameter(string realm, string blockId, string port)
{
Dictionary <string, object> attrs = new Dictionary <string, object>();
attrs.Add("realm", realm);
attrs.Add("block-id", realm);
attrs.Add("port", port);
return(this.communicator.Receive <PortDiagnostic>(XmlReadWrite.CreateFunctionRequest("debug-parameter", null, attrs), new NewThreadScheduler()));
}
/// <summary>
/// Observe the output of the specified port in the given realm.
/// </summary>
/// <param name="realm">target realm</param>
/// <param name="portId">port identifier of an input port returned by the queryPorts() method.</param>
/// <returns>observable which will send out the values</returns>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceControlException">if user is not has no right to access the realm/ports</exception>
public IObservable <XmlNode> ReceivePort(string realm, string portId)
{
Dictionary <string, object> attrs = new Dictionary <string, object>();
attrs.Add("realm", realm);
attrs.Add("port-id", portId);
return(this.communicator.Receive <XmlNode>(XmlReadWrite.CreateFunctionRequest("receve-port", null, attrs), new NewThreadScheduler()));
}
/// <summary>
/// Check if the user has the expected right
/// </summary>
/// <param name="userName">user's name</param>
/// <param name="expected">expected right</param>
/// <returns>true if has the expected right</returns>
public bool HasUserRight(string userName, AdvanceUserRights expected)
{
Dictionary <string, object> attrs = new Dictionary <string, object>();
attrs.Add("user-name", userName);
attrs.Add("expected", expected);
XmlNode resp = this.communicator.Query(XmlReadWrite.CreateFunctionRequest("has-user-right", null, attrs));
return(XmlReadWrite.GetBoolContent(resp, false));
}
public void Checklang()
{
Launcher obj = new Launcher();
XmlReadWrite xml = new XmlReadWrite();
if (xml.ReadXML())
{
obj.Checklang(false);
}
obj.Checklang(true);
}
/// <summary>
/// Query notification group
/// </summary>
/// <param name="type">group type</param>
/// <param name="name">group name</param>
/// <returns>set of contact information</returns>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceXMLException">On Xml parsing error</exception>
/// <exception cref="AdvanceControlException">if username or password is incorrect</exception>
public List <string> QueryNotificationGroup(AdvanceNotificationGroupType type, string name)
{
Dictionary <string, object> attrs = new Dictionary <string, object>();
attrs.Add("type", type);
attrs.Add("name", name);
XmlNode resp = this.communicator.Query(XmlReadWrite.CreateFunctionRequest("query-notification-group", null, attrs));
AdvanceNotificationGroup ng = XmlReadWrite.CreateFromXml <AdvanceNotificationGroup>(resp);
return(ng.Contacts);
}
/// <summary>
/// Fill object data from xml node
/// </summary>
/// <param name="source">Source Xml</param>
protected override void LoadFromXmlNode(XmlNode source)
{
this.Type = GetEnumAttribute <AdvanceNotificationGroupType>(source, "type", AdvanceNotificationGroupType.EMAIL);
this.Name = GetAttribute(source, "name", null);
HashSet <string> ret = new HashSet <string>();
foreach (XmlNode node in XmlReadWrite.GetChildren(source, "contact"))
{
ret.Add(XmlReadWrite.GetAttribute(node, "value"));
}
}
/// <summary>
/// Načítanie vstupu aplikácie z XML
/// </summary>
public void LoadDataXml()
{
Pouzivatelia = new HashSet <Pouzivatel>();
Skupiny = new HashSet <Skupina>();
XmlReadWrite RW = new XmlReadWrite();
//RW.LoadPouzivatelia("..\\..\\..\\DATA\\test_pouzivatelia.xml", t_Uziv);
//RW.LoadSkupiny("..\\..\\..\\DATA\\test_skupiny.xml", t_Skupiny);
RW.LoadPouzivatelia(_nastavenia.Get("cestaXML_Pouzivatelia"), Pouzivatelia);
RW.LoadSkupiny(_nastavenia.Get("cestaXML_Skupiny"), Skupiny);
}
/// <summary>
/// ends a sequence of values to the same or multiple ports in a batch.
/// </summary>
/// <param name="realm">target realm</param>
/// <param name="portValues">equence of port id and value XML pairs</param>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceControlException">if user is not has no right to access the realm/ports</exception>
public void SendPort(string realm, Dictionary <string, XmlNode> portValues)
{
XmlDocument req = XmlReadWrite.CreateFunctionRequest("send-port", "realm", realm);
foreach (KeyValuePair <string, XmlNode> pv in portValues)
{
XmlElement node = XmlReadWrite.AddAttributeNode(req.DocumentElement, "entry", "port", pv.Key);
node.AppendChild(req.ImportNode(pv.Value, true));
}
this.communicator.Send(req);
}
/// <summary>
/// Saves block state
/// </summary>
/// <param name="realm">target realm</param>
/// <param name="blockId">arget block identifier</param>
/// <param name="state">state Xml element or null</param>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceXMLException">On Xml parsing error</exception>
/// <exception cref="AdvanceControlException">if username or password is incorrect</exception>
public void UpdateBlockState(string realm, string blockId, XmlNode state)
{
XmlDocument req = XmlReadWrite.CreateFunctionRequest("update-block-state");
XmlReadWrite.AddAttribute(req.DocumentElement, "realm", realm);
XmlReadWrite.AddAttribute(req.DocumentElement, "block-id", blockId);
if (state != null)
{
req.DocumentElement.AppendChild(req.ImportNode(state, true));
}
this.communicator.Send(req);
}
/// <summary>
/// Inject a value into the given realm/block/input port.
/// </summary>
/// <param name="realm">realm</param>
/// <param name="blockId">block unique identifier (as in the flow)</param>
/// <param name="port">port name</param>
/// <param name="value">as XNElement to inject</param>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceControlException">if user is not allowed to debug in the realm or referenced parameter is missing.</exception>
public void InjectValue(string realm, string blockId, string port, XmlElement value)
{
Dictionary <string, object> attrs = new Dictionary <string, object>();
attrs.Add("realm", realm);
attrs.Add("block-id", blockId);
attrs.Add("port", port);
XmlDocument req = XmlReadWrite.CreateFunctionRequest("inject-value", null, attrs);
req.DocumentElement.AppendChild(req.ImportNode(value, true));
this.communicator.Send(req);
}
/// <summary>
/// Update a flow in a the given realm.
/// </summary>
/// <param name="realm">target realm</param>
/// <param name="block">Flow content to upload</param>
/// <param name="byUser">user who modifies the realm</param>
/// <exception cref="AdvanceIOException">if network connection failed</exception>
/// <exception cref="AdvanceControlException">if user is not allowed to update a flow.</exception>
public void UpdateFlow(string realm, AdvanceCompositeBlock block, string byUser)
{
Dictionary <string, object> attrs = new Dictionary <string, object>();
attrs.Add("realm", realm);
attrs.Add("by-user", byUser);
List <XmlReadWrite> pars = new List <XmlReadWrite>();
pars.Add(new AdvanceFlow(block));
XmlDocument req = XmlReadWrite.CreateFunctionRequest("update-flow", pars, attrs);
this.communicator.Send(req);
}
private void btnInvoke_Click(object sender, EventArgs e)
{
InterfaceDescription selectedInterface = this.cmbInterfaces.SelectedItem as InterfaceDescription;
string method = this.cmbMethods.SelectedItem as string;
object[] ps = GetActualParameters(selectedInterface.GetMethodParameters(method));
try
{
this.rtxtResults.Clear();
this.AddMessageLine("Invoke '" + method + "' from '" + selectedInterface);
object response = selectedInterface.InvokeMethod(method, ps);
if (response != null)
{
Type respType = response.GetType();
if (respType.IsPrimitive || respType.Equals(typeof(string)))
{
this.AddMessageLine(response.ToString());
}
else
{
string fn = (this.outputDir == "") ? null : Utils.GetFilenameForCreate(this.outputDir, method, "xml");
if (fn != null)
{
this.AddMessageLine("Output in file: " + fn);
}
if (response is IObservable <XmlNode> )
{
this.StartObservable <XmlNode>(response as IObservable <XmlNode>, fn);
}
else if (response is IObservable <XmlNode> )
{
this.StartObservable <XmlReadWrite>(response as IObservable <XmlReadWrite>, fn);
}
else
{
if (fn != null)
{
XmlReadWrite.WriteToFile(fn, response);
}
XmlReadWrite xmlObj = (response is XmlReadWrite) ? (response as XmlReadWrite) : new XmlObjectSerializer(response);
this.AddMessageLine(xmlObj.ToString());
}
}
}
}
catch (Exception ex)
{
this.AddErrMessage("Error", ex);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
_configuration = XmlReadWrite.Read("/XML/", _configuration, "set.config") as WeiXinConfiguration;
if (_configuration != null)
{
txt_appid.Text = _configuration.Appid;
txt_secret.Text = _configuration.AppSecret;
txt_token.Text = _configuration.Token;
txt_encodingaeskey.Value = _configuration.EncodingAESKey;
}
}
}
public HttpResponseMessage Register(Register data)
{
var user = ParseAuthorizationHeader(this.Request);
var result = XmlReadWrite.Register(user[0], user[1]);
if (result)
{
return(Request.CreateResponse(HttpStatusCode.OK, ""));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "username taken"));
}
}
/// <summary>
/// Načítanie vstupu aplikácie z jednotlivého XML
/// </summary>
/// <param name="paCesta">Cesta k súboru</param>
/// <param name="paNacitanie">Typ načítania True -> načíta skupiny, False -> načíta používateľov</param>
public void LoadDataXmlImport(string paCesta, bool paNacitanie)
{
XmlReadWrite RW = new XmlReadWrite();
if (paNacitanie)
{
Skupiny = new HashSet <Skupina>();
RW.LoadSkupiny(paCesta, Skupiny);
}
else
{
Pouzivatelia = new HashSet <Pouzivatel>();
RW.LoadPouzivatelia(paCesta, Pouzivatelia);
}
}
private object GetActualParameter(Type parType, object value)
{
if (parType.Equals(typeof(String)))
{
return(value);
}
else if (parType.IsPrimitive)
{
return(Convert.ChangeType(value, parType));
}
else
{
XmlNode node = XmlReadWrite.ReadFromStream(File.OpenRead((string)value));
return(XmlReadWrite.CreateFromXml(parType, node));
}
}
