private bool Respond(bool CanControl, string RuleXml, IqResultEventHandlerAsync Callback, object State)
{
StringBuilder Xml = new StringBuilder();
Xml.Append("<canControlRule xmlns='");
Xml.Append(ProvisioningClient.NamespaceProvisioningOwner);
Xml.Append("' jid='");
Xml.Append(XML.Encode(this.JID));
Xml.Append("' remoteJid='");
Xml.Append(XML.Encode(this.RemoteJID));
Xml.Append("' key='");
Xml.Append(XML.Encode(this.Key));
Xml.Append("' result='");
Xml.Append(CommonTypes.Encode(CanControl));
Xml.Append("'>");
Xml.Append(RuleXml);
Xml.Append("</canControlRule>");
RosterItem Item = this.Client.Client[this.FromBareJID];
if (Item.HasLastPresence && Item.LastPresence.IsOnline)
{
this.Client.Client.SendIqSet(Item.LastPresenceFullJid, Xml.ToString(), Callback, State);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Unsubscribes to updates to a given software package.
/// </summary>
/// <param name="FileName">Filename of software package. If using a <see cref="Wildcard"/>,
/// events will be received when any software package is updated.</param>
/// <param name="Callback">Method to call when response is returned.</param>
/// <param name="State">State object to pass on to callback method.</param>
public void Unsubscribe(string FileName, IqResultEventHandlerAsync Callback, object State)
{
StringBuilder Xml = new StringBuilder();
Xml.Append("<unsubscribe xmlns='");
Xml.Append(NamespaceSoftwareUpdates);
Xml.Append("' fileName='");
Xml.Append(XML.Encode(FileName));
Xml.Append("'/>");
this.client.SendIqSet(this.componentAddress, Xml.ToString(), Callback, State);
}
private async Task CallCallback(IqResultEventHandlerAsync Callback, object State, IqResultEventArgs e)
{
if (!(Callback is null))
{
try
{
e.State = State;
await Callback(this, e);
}
catch (Exception ex)
{
Log.Critical(ex);
}
}
}
internal PendingRequest(uint SeqNr, PresenceEventHandlerAsync Callback, object State, int RetryTimeout, int NrRetries, bool DropOff, int MaxRetryTimeout,
string To)
{
this.seqNr = SeqNr;
this.iqCallback = null;
this.presenceCallback = Callback;
this.state = State;
this.retryTimeout = RetryTimeout;
this.nrRetries = NrRetries;
this.maxRetryTimeout = MaxRetryTimeout;
this.dropOff = DropOff;
this.to = To;
this.timeout = DateTime.Now.AddMilliseconds(RetryTimeout);
}
/// <summary>
/// Unblocks all JIDs
/// </summary>
/// <param name="Callback">Callback method.</param>
/// <param name="State">State object to pass on to callback method.</param>
public async Task UnblockAll(IqResultEventHandlerAsync Callback, object State)
{
if (this.supportsBlocking)
{
this.client.SendIqSet(this.client.Domain, "<unblock xmlns='" + NamespaceBlocking + "'/>", async(sender, e) =>
{
if (e.Ok)
{
lock (this.blockList)
{
this.blockList.Clear();
}
}
await this.CallCallback(Callback, State, e);
}, null);
}
else
{
await this.CallCallback(Callback, State, new IqResultEventArgs(null, string.Empty, string.Empty, string.Empty, false, State));
}
}
private void BeginSearchSupport()
{
Client.SendServiceDiscoveryRequest(Client.Domain, async(sender, e) =>
{
if (e.Ok)
{
this.supportsBlocking = e.HasFeature(NamespaceBlocking);
this.supportsReporting = e.HasFeature(NamespaceReporting);
this.supportsSpamReason = e.HasFeature(NamespaceSpamReason);
this.supportsAbuseReason = e.HasFeature(NamespaceAbuseReason);
if (this.supportsBlocking)
{
this.StartGetBlockList(null, null);
}
}
else
{
this.supportsBlocking = false;
this.supportsReporting = false;
this.supportsSpamReason = false;
this.supportsAbuseReason = false;
}
IqResultEventHandlerAsync h = this.OnSearchSupportResponse;
if (!(h is null))
{
try
{
await h(this, e);
}
catch (Exception ex)
{
Log.Critical(ex);
}
}
}, null);
}
/// <summary>
/// Unblocks a JID
/// </summary>
/// <param name="JID">JID to unblock.</param>
/// <param name="Callback">Callback method.</param>
/// <param name="State">State object to pass on to callback method.</param>
public async Task UnblockJID(string JID, IqResultEventHandlerAsync Callback, object State)
{
bool Blocked;
lock (this.blockList)
{
if (!this.blockList.TryGetValue(JID, out Blocked))
{
Blocked = false;
}
}
if (!Blocked)
{
await this.CallCallback(Callback, State, new IqResultEventArgs(null, string.Empty, string.Empty, string.Empty, true, State));
}
else if (this.supportsBlocking)
{
this.client.SendIqSet(this.client.Domain, "<unblock xmlns='" + NamespaceBlocking + "'><item jid='" + JID + "'/></unblock>",
async(sender, e) =>
{
if (e.Ok)
{
lock (this.blockList)
{
this.blockList.Remove(JID);
}
}
await this.CallCallback(Callback, State, e);
}, null);
}
else
{
await this.CallCallback(Callback, State, new IqResultEventArgs(null, string.Empty, string.Empty, string.Empty, false, State));
}
}
/// <summary>
/// Deletes a message object from the broker.
/// </summary>
/// <param name="ObjectId">ID of the message object to delete.</param>
/// <param name="Callback">Method to call when response has been returned.</param>
/// <param name="State">State object to pass on to callback method.</param>
public void Delete(string ObjectId, IqResultEventHandlerAsync Callback, object State)
{
this.client.SendIqSet(this.client.Domain, "<delete xmlns='" + NamespaceMail + "' cid='" + XML.Encode(ObjectId) + "'/>",
Callback, State);
}
/// <summary>
/// Reject control operations from this user.
/// </summary>
/// <param name="UserToken">Which user token is to be rejected.</param>
/// <param name="Callback">Callback method to call when response is received.</param>
/// <param name="State">State object to pass on to the callback method.</param>
/// <returns>If the response could be sent.</returns>
public bool RejectAllFromUser(string UserToken, IqResultEventHandlerAsync Callback, object State)
{
return(this.Respond(false, "<fromUser token='" + XML.Encode(UserToken) + "'/>", Callback, State));
}
/// <summary>
/// Reject control operations from this remote JID.
/// </summary>
/// <param name="Callback">Callback method to call when response is received.</param>
/// <param name="State">State object to pass on to the callback method.</param>
/// <returns>If the response could be sent.</returns>
public bool RejectAllFromJID(IqResultEventHandlerAsync Callback, object State)
{
return(this.Respond(false, "<fromJid/>", Callback, State));
}
/// <summary>
/// Accept partial control operations from this user.
/// </summary>
/// <param name="Parameters">Parameters that can be controlled.</param>
/// <param name="UserToken">Which user token is to be accepted.</param>
/// <param name="Callback">Callback method to call when response is received.</param>
/// <param name="State">State object to pass on to the callback method.</param>
/// <returns>If the response could be sent.</returns>
public bool AcceptPartialFromUser(string[] Parameters, string UserToken, IqResultEventHandlerAsync Callback, object State)
{
return(this.Respond(true, this.PartialParameters(Parameters) + "<fromUser token='" + XML.Encode(UserToken) + "'/>", Callback, State));
}
/// <summary>
/// Accept partial control operations from all entities of the remote domain.
/// </summary>
/// <param name="Parameters">Parameters that can be controlled.</param>
/// <param name="Callback">Callback method to call when response is received.</param>
/// <param name="State">State object to pass on to the callback method.</param>
/// <returns>If the response could be sent.</returns>
public bool AcceptPartialFromDomain(string[] Parameters, IqResultEventHandlerAsync Callback, object State)
{
return(this.Respond(true, this.PartialParameters(Parameters) + "<fromDomain/>", Callback, State));
}
/// <summary>
/// Rejects the friendship, and similar future requests from the entire remote domain.
/// </summary>
public void RejectForEntireDomain(IqResultEventHandlerAsync Callback, object State)
{
this.Respond(false, RuleRange.Domain, Callback, State);
}
/// <summary>
/// Accept partial readouts from this device.
/// </summary>
/// <param name="Fields">Fields that can be read.</param>
/// <param name="FieldTypes">Field categories that can be read.</param>
/// <param name="DeviceToken">Which device token is to be accepted.</param>
/// <param name="Callback">Callback method to call when response is received.</param>
/// <param name="State">State object to pass on to the callback method.</param>
/// <returns>If the response could be sent.</returns>
public bool AcceptPartialFromDevice(string[] Fields, FieldType FieldTypes, string DeviceToken, IqResultEventHandlerAsync Callback, object State)
{
return(this.Respond(true, this.PartialFields(Fields, FieldTypes) + "<fromDevice token='" + XML.Encode(DeviceToken) + "'/>", Callback, State));
}
/// <summary>
/// Accept partial readouts from all entities of the remote domain.
/// </summary>
/// <param name="Fields">Fields that can be read.</param>
/// <param name="FieldTypes">Field categories that can be read.</param>
/// <param name="Callback">Callback method to call when response is received.</param>
/// <param name="State">State object to pass on to the callback method.</param>
/// <returns>If the response could be sent.</returns>
public bool AcceptPartialFromDomain(string[] Fields, FieldType FieldTypes, IqResultEventHandlerAsync Callback, object State)
{
return(this.Respond(true, this.PartialFields(Fields, FieldTypes) + "<fromDomain/>", Callback, State));
}
/// <summary>
/// Accepts the friendship.
/// </summary>
/// <param name="Callback">Callback method to call when response is received.</param>
/// <param name="State">State object to pass on to the callback method.</param>
public void Accept(IqResultEventHandlerAsync Callback, object State)
{
this.Respond(true, RuleRange.Caller, Callback, State);
}
/// <summary>
/// Accept control operations from all entities of the remote domain.
/// </summary>
/// <param name="Callback">Callback method to call when response is received.</param>
/// <param name="State">State object to pass on to the callback method.</param>
/// <returns>If the response could be sent.</returns>
public bool AcceptAllFromDomain(IqResultEventHandlerAsync Callback, object State)
{
return(this.Respond(true, "<fromDomain/>", Callback, State));
}
/// <summary>
/// Rejects the friendship, and all future requests.
/// </summary>
public void RejectForAll(IqResultEventHandlerAsync Callback, object State)
{
this.Respond(false, RuleRange.All, Callback, State);
}
/// <summary>
/// Blocks a JID
/// </summary>
/// <param name="JID">JID to block.</param>
/// <param name="Reason">Reason for blocking JID.</param>
/// <param name="Callback">Callback method.</param>
/// <param name="State">State object to pass on to callback method.</param>
public async Task BlockJID(string JID, ReportingReason Reason, IqResultEventHandlerAsync Callback, object State)
{
bool Blocked;
lock (this.blockList)
{
if (!this.blockList.TryGetValue(JID, out Blocked))
{
Blocked = false;
}
}
if (Blocked)
{
await this.CallCallback(Callback, State, new IqResultEventArgs(null, string.Empty, string.Empty, string.Empty, true, State));
}
else if (this.supportsBlocking)
{
StringBuilder Xml = new StringBuilder();
Xml.Append("<block xmlns='");
Xml.Append(NamespaceBlocking);
Xml.Append("'><item jid='");
Xml.Append(JID);
if (!this.supportsReporting)
{
Xml.Append("'/></block>");
}
else if (Reason == ReportingReason.Spam && this.supportsSpamReason)
{
Xml.Append("'><report xmlns='");
Xml.Append(NamespaceReporting);
Xml.Append("'><spam/></report></item></block>");
}
else if (Reason == ReportingReason.Abuse && this.supportsAbuseReason)
{
Xml.Append("'><report xmlns='");
Xml.Append(NamespaceReporting);
Xml.Append("'><abuse/></report></item></block>");
}
else
{
Xml.Append("'/></block>");
}
this.client.SendIqSet(this.client.Domain, Xml.ToString(), async(sender, e) =>
{
if (e.Ok)
{
lock (this.blockList)
{
this.blockList[JID] = true;
}
}
await this.CallCallback(Callback, State, e);
}, null);
}
else
{
await this.CallCallback(Callback, State, new IqResultEventArgs(null, string.Empty, string.Empty, string.Empty, false, State));
}
}
/// <summary>
/// Accept control operations from this service.
/// </summary>
/// <param name="ServiceToken">Which service token is to be accepted.</param>
/// <param name="Callback">Callback method to call when response is received.</param>
/// <param name="State">State object to pass on to the callback method.</param>
/// <returns>If the response could be sent.</returns>
public bool AcceptAllFromService(string ServiceToken, IqResultEventHandlerAsync Callback, object State)
{
return(this.Respond(true, "<fromService token='" + XML.Encode(ServiceToken) + "'/>", Callback, State));
}
private void Respond(bool IsFriend, RuleRange Range, IqResultEventHandlerAsync Callback, object State)
{
this.Client.IsFriendResponse(this.JID, this.RemoteJID, this.Key, IsFriend, Range, Callback, State);
}
