public override void Status(Pubnub pubnub, PNStatus status)
{
//Console.WriteLine("SubscribeCallback: PNStatus: " + pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
Console.WriteLine("SubscribeCallback: PNStatus: " + status.StatusCode.ToString());
if (status.StatusCode != 200 || status.Error)
{
switch (currentTestCase)
{
case "ThenShouldReturnUnsubscribedMessage":
subscribeManualEvent.Set();
break;
default:
break;
}
Console.ForegroundColor = ConsoleColor.Red;
if (status.ErrorData != null)
{
Console.WriteLine(status.ErrorData.Information);
}
Console.ForegroundColor = ConsoleColor.White;
}
else if (status.StatusCode == 200 && status.Category == PNStatusCategory.PNConnectedCategory)
{
switch (currentTestCase)
{
case "ThenShouldReturnUnsubscribedMessage":
receivedMessage = true;
subscribeManualEvent.Set();
break;
default:
break;
}
}
else if (status.StatusCode == 200 && status.Category == PNStatusCategory.PNDisconnectedCategory)
{
switch (currentTestCase)
{
case "ThenShouldReturnUnsubscribedMessage":
receivedMessage = true;
subscribeManualEvent.Set();
break;
default:
break;
}
}
}
private void ProcessGetFileUrl(Dictionary <string, object> externalQueryParam, PNCallback <PNFileUrlResult> callback)
{
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildGetFileUrlOrDeleteReqest("GET", "", this.channelName, this.currentFileId, this.currentFileName, externalQueryParam, PNOperationType.PNFileUrlOperation);
PNFileUrlResult result = new PNFileUrlResult();
result.Url = request.ToString();
PNStatus status = new PNStatus {
Error = false, StatusCode = 200
};
callback.OnResponse(result, status);
}
private async Task <PNResult <PNPublishFileMessageResult> > PublishFileMessage(object message, Dictionary <string, object> externalQueryParam)
{
PNResult <PNPublishFileMessageResult> ret = new PNResult <PNPublishFileMessageResult>();
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildPublishFileMessageRequest("GET", "", this.channelName, message, this.storeInHistory, this.ttl, this.userMetadata, null, externalQueryParam);
RequestState <PNPublishFileMessageResult> requestState = new RequestState <PNPublishFileMessageResult>();
requestState.Channels = new[] { this.channelName };
requestState.ResponseType = PNOperationType.PNPublishFileMessageOperation;
requestState.PubnubCallback = null;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
string json = "";
await UrlProcessRequest(request, requestState, false).ContinueWith(r =>
{
json = r.Result.Item1;
if (!string.IsNullOrEmpty(json))
{
List <object> result = ProcessJsonResponse(requestState, json);
ResponseBuilder responseBuilder = new ResponseBuilder(config, jsonLibrary, pubnubLog);
PNPublishFileMessageResult publishResult = responseBuilder.JsonToObject <PNPublishFileMessageResult>(result, true);
StatusBuilder statusBuilder = new StatusBuilder(config, jsonLibrary);
if (publishResult != null)
{
ret.Result = publishResult;
PNStatus status = statusBuilder.CreateStatusResponse(requestState.ResponseType, PNStatusCategory.PNAcknowledgmentCategory, requestState, (int)HttpStatusCode.OK, null);
ret.Status = status;
}
else
{
PNException ex = new PNException("File has been upload but the notification couldn't be sent to the subscribed users");
PNStatus status = statusBuilder.CreateStatusResponse(requestState.ResponseType, PNStatusCategory.PNUnknownCategory, requestState, (int)HttpStatusCode.BadRequest, ex);
status.AdditonalData = new Dictionary <string, string> {
{ "FileId", currentFileId }, { "FileName", sendFileName }
};
ret.Status = status;
}
}
}, TaskContinuationOptions.ExecuteSynchronously);
return(ret);
}
public override void Status(Pubnub pubnub, PNStatus status)
{
Debug.WriteLine("SubscribeCallback: PNStatus: " + status.StatusCode.ToString());
if (status.StatusCode != 200 || status.Error)
{
switch (currentTestCase)
{
case "ThenShouldReturnUnsubscribedMessage":
subscribeManualEvent.Set();
break;
default:
break;
}
if (status.ErrorData != null)
{
Debug.WriteLine(status.ErrorData.Information);
}
}
else if (status.StatusCode == 200 && status.Category == PNStatusCategory.PNConnectedCategory)
{
switch (currentTestCase)
{
case "ThenShouldReturnUnsubscribedMessage":
receivedMessage = true;
subscribeManualEvent.Set();
break;
default:
break;
}
}
else if (status.StatusCode == 200 && status.Category == PNStatusCategory.PNDisconnectedCategory)
{
switch (currentTestCase)
{
case "ThenShouldReturnUnsubscribedMessage":
receivedMessage = true;
subscribeManualEvent.Set();
break;
default:
break;
}
}
}
public override void OnResponse(PNAccessManagerGrantResult result, PNStatus status)
{
try
{
Console.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
if (result != null)
{
Console.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
}
}
catch { }
finally
{
revokeManualEvent.Set();
}
}
private async Task <PNResult <PNRemoveUuidMetadataResult> > RemoveUuidMetadata(string uuid, Dictionary <string, object> externalQueryParam)
{
PNResult <PNRemoveUuidMetadataResult> ret = new PNResult <PNRemoveUuidMetadataResult>();
if (string.IsNullOrEmpty(uuid))
{
uuid = config.Uuid;
}
if (string.IsNullOrEmpty(config.SubscribeKey) || string.IsNullOrEmpty(config.SubscribeKey.Trim()) || config.SubscribeKey.Length <= 0)
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid Subscribe key", new ArgumentException("Invalid Subscribe key"))
};
ret.Status = errStatus;
return(ret);
}
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildDeleteUuidMetadataRequest("DELETE", "", uuid, externalQueryParam);
RequestState <PNRemoveUuidMetadataResult> requestState = new RequestState <PNRemoveUuidMetadataResult>();
requestState.ResponseType = PNOperationType.PNDeleteUuidMetadataOperation;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
Tuple <string, PNStatus> JsonAndStatusTuple = await UrlProcessRequest(request, requestState, false).ConfigureAwait(false);
ret.Status = JsonAndStatusTuple.Item2;
string json = JsonAndStatusTuple.Item1;
if (!string.IsNullOrEmpty(json))
{
List <object> resultList = ProcessJsonResponse(requestState, json);
ResponseBuilder responseBuilder = new ResponseBuilder(config, jsonLibrary, pubnubLog);
PNRemoveUuidMetadataResult responseResult = responseBuilder.JsonToObject <PNRemoveUuidMetadataResult>(resultList, true);
if (responseResult != null)
{
ret.Result = responseResult;
}
}
return(ret);
}
public override void OnResponse(PNAccessManagerAuditResult result, PNStatus status)
{
try
{
Console.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
if (result != null)
{
Console.WriteLine("PNAccessManagerAuditResult={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
if (status.StatusCode == 200 && status.Error == false)
{
if (!String.IsNullOrEmpty(result.Channel))
{
var channels = result.Channel.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine("CleanupGrant / AtUserLevel / UserCallbackForCleanUpAccess - Channel Count = {0}", channels.Length);
foreach (string channelName in channels)
{
if (result.AuthKeys != null)
{
foreach (string authKey in result.AuthKeys.Keys)
{
Console.WriteLine("Auth Key = " + authKey);
revokeManualEvent = new ManualResetEvent(false);
pubnub.Grant().Channels(new string[] { channelName }).AuthKeys(new string[] { authKey }).Read(false).Write(false).Manage(false).Async(new GrantResult());
revokeManualEvent.WaitOne();
}
}
}
}
if (result.Level == "subkey")
{
receivedAuditMessage = true;
}
}
}
}
catch
{
}
finally
{
auditManualEvent.Set();
}
}
public override void OnResponse(PNDeleteMessageResult result, PNStatus status)
{
Console.WriteLine("DeleteMessage Response: " + pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
Console.WriteLine("DeleteMessage PNStatus => Status = : " + status.StatusCode.ToString());
if (result != null && status.StatusCode == 200 && !status.Error)
{
switch (currentTestCase)
{
case "DeleteMessageShouldReturnSuccessMessage":
receivedMessage = true;
deleteMessageManualEvent.Set();
break;
default:
break;
}
}
}
public override void OnResponse(PNAccessManagerGrantResult result, PNStatus status)
{
try
{
Debug.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
if (result != null)
{
Debug.WriteLine("PNAccessManagerGrantResult={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
if (result.Channels != null && result.Channels.Count > 0)
{
foreach (KeyValuePair <string, Dictionary <string, PNAccessManagerKeyData> > channelKP in result.Channels)
{
string channel = channelKP.Key;
if (Array.IndexOf(channelsGrant, channel) > -1)
{
var read = result.Channels[channel][authKey].ReadEnabled;
var write = result.Channels[channel][authKey].WriteEnabled;
if (read && write)
{
receivedGrantMessage = true;
}
else
{
receivedGrantMessage = false;
}
}
else
{
receivedGrantMessage = false;
break;
}
}
}
}
}
catch
{
}
finally
{
grantManualEvent.Set();
}
}
private async Task <PNResult <PNGetChannelMetadataResult> > GetSingleChannelMetadata(string spaceId, bool includeCustom, Dictionary <string, object> externalQueryParam)
{
PNResult <PNGetChannelMetadataResult> ret = new PNResult <PNGetChannelMetadataResult>();
if (string.IsNullOrEmpty(this.chMetadataId))
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Missing Channel", new ArgumentException("Missing Channel"))
};
ret.Status = errStatus;
return(ret);
}
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildGetSingleChannelMetadataRequest("GET", "", spaceId, includeCustom, externalQueryParam);
RequestState <PNGetChannelMetadataResult> requestState = new RequestState <PNGetChannelMetadataResult>();
requestState.ResponseType = PNOperationType.PNGetChannelMetadataOperation;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
requestState.UsePostMethod = false;
Tuple <string, PNStatus> JsonAndStatusTuple = await UrlProcessRequest(request, requestState, false).ConfigureAwait(false);
ret.Status = JsonAndStatusTuple.Item2;
string json = JsonAndStatusTuple.Item1;
if (!string.IsNullOrEmpty(json))
{
List <object> resultList = ProcessJsonResponse(requestState, json);
ResponseBuilder responseBuilder = new ResponseBuilder(config, jsonLibrary, pubnubLog);
PNGetChannelMetadataResult responseResult = responseBuilder.JsonToObject <PNGetChannelMetadataResult>(resultList, true);
if (responseResult != null)
{
ret.Result = responseResult;
}
}
return(ret);
}
private async Task <PNResult <PNListFilesResult> > ProcessListFilesRequest(Dictionary <string, object> externalQueryParam)
{
PNResult <PNListFilesResult> ret = new PNResult <PNListFilesResult>();
if (string.IsNullOrEmpty(this.channelName))
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid Channel name", new ArgumentException("Invalid Channel name"))
};
ret.Status = errStatus;
return(ret);
}
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildListFilesReqest("GET", "", this.channelName, this.limitFileCount, this.nextFileBatchToken, externalQueryParam, PNOperationType.PNListFilesOperation);
RequestState <PNListFilesResult> requestState = new RequestState <PNListFilesResult>();
requestState.ResponseType = PNOperationType.PNListFilesOperation;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
requestState.UsePostMethod = false;
Tuple <string, PNStatus> JsonAndStatusTuple = await UrlProcessRequest(request, requestState, false).ConfigureAwait(false);
ret.Status = JsonAndStatusTuple.Item2;
string json = JsonAndStatusTuple.Item1;
if (!string.IsNullOrEmpty(json))
{
List <object> resultList = ProcessJsonResponse(requestState, json);
ResponseBuilder responseBuilder = new ResponseBuilder(config, jsonLibrary, pubnubLog);
PNListFilesResult responseResult = responseBuilder.JsonToObject <PNListFilesResult>(resultList, true);
if (responseResult != null)
{
ret.Result = responseResult;
}
}
return(ret);
}
public override void OnResponse(PNAccessManagerGrantResult result, PNStatus status)
{
try
{
Debug.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
if (result != null)
{
Debug.WriteLine("PNAccessManagerAuditResult={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
receivedGrantMessage = true;
}
}
catch
{
}
finally
{
grantManualEvent.Set();
}
}
public override void OnResponse(PNPublishResult result, PNStatus status)
{
Console.WriteLine("Publish Response: " + pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
Console.WriteLine("Publish PNStatus => Status = : " + status.StatusCode.ToString());
if (result != null && status.StatusCode == 200 && !status.Error)
{
publishTimetoken = result.Timetoken;
switch (currentTestCase)
{
case "ThenSubscribeShouldReturnReceivedMessage":
receivedMessage = true;
break;
default:
break;
}
}
publishManualEvent.Set();
}
private async Task <PNResult <PNFileUrlResult> > ProcessGetFileUrl(Dictionary <string, object> externalQueryParam)
{
PNResult <PNFileUrlResult> ret = new PNResult <PNFileUrlResult>();
if (string.IsNullOrEmpty(this.currentFileId))
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Missing File Id", new ArgumentException("Missing File Id"))
};
ret.Status = errStatus;
return(ret);
}
if (string.IsNullOrEmpty(this.currentFileName))
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid file name", new ArgumentException("Invalid file name"))
};
ret.Status = errStatus;
return(ret);
}
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildGetFileUrlOrDeleteReqest("GET", "", this.channelName, this.currentFileId, this.currentFileName, externalQueryParam, PNOperationType.PNFileUrlOperation);
PNFileUrlResult result = new PNFileUrlResult();
result.Url = request.ToString();
PNStatus status = new PNStatus {
Error = false, StatusCode = 200
};
ret.Result = result;
ret.Status = status;
await Task.Factory.StartNew(() => { }).ConfigureAwait(false);//dummy stmt.
return(ret);
}
public override void OnResponse(PNAccessManagerGrantResult result, PNStatus status)
{
try
{
if (result != null && status.StatusCode == 200 && !status.Error)
{
Console.WriteLine("PNAccessManagerGrantResult={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
if (result.Channels != null && result.Channels.Count > 0)
{
var read = result.Channels[channel][authKey].ReadEnabled;
var write = result.Channels[channel][authKey].WriteEnabled;
if (read && write)
{
receivedGrantMessage = true;
}
}
else if (result.ChannelGroups != null && result.ChannelGroups.Count > 0)
{
var read = result.ChannelGroups[channelGroupName][authKey].ReadEnabled;
var write = result.ChannelGroups[channelGroupName][authKey].WriteEnabled;
var manage = result.ChannelGroups[channelGroupName][authKey].ManageEnabled;
if (read && write && manage)
{
receivedGrantMessage = true;
}
}
}
else
{
Console.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
}
}
catch
{
}
finally
{
grantManualEvent.Set();
}
}
public override void Status(Pubnub pubnub, PNStatus status)
{
string msg = string.Format("Operation: {0}; Category: {1}; StatusCode: {2}", status.Operation, status.Category, status.StatusCode);
this.callback(msg);
//if (status.StatusCode != 200 || status.Error)
//{
// Console.ForegroundColor = ConsoleColor.Red;
// if (status.ErrorData != null)
// {
// Console.WriteLine(status.ErrorData.Information);
// }
// Console.ForegroundColor = ConsoleColor.White;
//}
if (status.Category == PNStatusCategory.PNUnexpectedDisconnectCategory)
{
// This event happens when radio / connectivity is lost
}
else if (status.Category == PNStatusCategory.PNConnectedCategory)
{
//Console.WriteLine("CONNECTED {0} Channels = {1}, ChannelGroups = {2}", status.StatusCode, string.Join(",", status.AffectedChannels), string.Join(",", status.AffectedChannelGroups));
// Connect event. You can do stuff like publish, and know you'll get it.
// Or just use the connected event to confirm you are subscribed for
// UI / internal notifications, etc
}
else if (status.Category == PNStatusCategory.PNReconnectedCategory)
{
//Console.WriteLine("RE-CONNECTED {0} Channels = {1}, ChannelGroups = {2}", status.StatusCode, string.Join(",", status.AffectedChannels), string.Join(",", status.AffectedChannelGroups));
// Happens as part of our regular operation. This event happens when
// radio / connectivity is lost, then regained.
}
else if (status.Category == PNStatusCategory.PNDecryptionErrorCategory)
{
// Handle messsage decryption error. Probably client configured to
// encrypt messages and on live data feed it received plain text.
}
}
public override void OnResponse(PNAccessManagerGrantResult result, PNStatus status)
{
try
{
Console.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
if (status.Error == false)
{
receivedGrantMessage = true;
}
if (result != null)
{
Console.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
}
}
catch
{ }
finally
{
grantManualEvent.Set();
channelGroupManualEvent.Set();
}
}
public override void OnResponse(PNPublishResult result, PNStatus status)
{
Debug.WriteLine("Publish Response: " + pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
Debug.WriteLine("Publish PNStatus => Status = : " + status.StatusCode.ToString());
if (result != null && status.StatusCode == 200 && !status.Error)
{
publishTimetoken = result.Timetoken;
switch (currentTestCase)
{
case "ThenPublishMpnsToastShouldReturnSuccess":
case "ThenPublishMpnsFlipTileShouldReturnSuccess":
case "ThenPublishMpnsCycleTileShouldReturnSuccess":
case "ThenPublishMpnsIconicTileShouldReturnSuccess":
receivedMessage = true;
break;
default:
break;
}
}
publishManualEvent.Set();
}
public override void OnResponse(PNChannelGroupsAddChannelResult result, PNStatus status)
{
try
{
Console.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
if (result != null)
{
Console.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
if (status.StatusCode == 200 && status.Error == false && status.AffectedChannelGroups.Contains(channelGroupName))
{
receivedMessage = true;
}
}
}
catch
{
}
finally
{
cgManualEvent.Set();
}
}
public override void OnResponse(PNChannelGroupsListAllResult result, PNStatus status)
{
try
{
Debug.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
if (result != null)
{
Debug.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
if (status.StatusCode == 200 && status.Error == false)
{
receivedChannelGroupMessage = true;
}
}
}
catch
{
}
finally
{
channelGroupManualEvent.Set();
}
}
//private void PresenceCallback(Pubnub pubnubObj, PNPresenceEventResult presence) { }
private void HandleStatusCallback(Pubnub pubnubObj, PNStatus status)
{
if (status.Category == PNStatusCategory.PNUnexpectedDisconnectCategory)
{
// This event happens when radio / connectivity is lost
}
else if (status.Category == PNStatusCategory.PNConnectedCategory)
{
// Connect event. You can do stuff like publish, and know you'll get it.
// Or just use the connected event to confirm you are subscribed for
// UI / internal notifications, etc.
PubnubConnected?.Invoke(EventArgs.Empty);
}
else if (status.Category == PNStatusCategory.PNReconnectedCategory)
{
// Happens as part of our regular operation. This event happens when
// radio / connectivity is lost, then regained.
}
else if (status.Category == PNStatusCategory.PNDecryptionErrorCategory)
{
// Handle message decryption error. Probably client configured to
// encrypt messages and on live data feed it received plain text.
}
}
public override void OnResponse(PNChannelGroupsAddChannelResult result, PNStatus status)
{
try
{
Console.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
if (result != null)
{
Console.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
//if (status.StatusCode == 200 && result.Message.ToLower() == "ok" && result.Service == "channel-registry"&& status.Error == false && result.ChannelGroup.Substring(1) == channelGroupName)
switch (currentTestCase)
{
case "ThenMultiSubscribeShouldReturnConnectStatus":
if (status.StatusCode == 200 && status.Error == false && (status.AffectedChannelGroups.Contains(channelGroupName1) || status.AffectedChannelGroups.Contains(channelGroupName2)))
{
receivedMessage = true;
}
break;
default:
if (status.StatusCode == 200 && status.Error == false && status.AffectedChannelGroups.Contains(channelGroupName))
{
receivedMessage = true;
}
break;
}
}
}
catch
{
}
finally
{
channelGroupManualEvent.Set();
}
}
public override void OnResponse(PNPublishResult result, PNStatus status)
{
Debug.WriteLine("Publish Response: " + pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
Debug.WriteLine("Publish PNStatus => Status = : " + status.StatusCode.ToString());
if (result != null && status.StatusCode == 200 && !status.Error)
{
publishTimetoken = result.Timetoken;
switch (currentTestCase)
{
case "ThenSubscribeShouldReturnReceivedMessage":
case "ThenSubscribeShouldReturnReceivedMessageSSL":
case "ThenSubscribeShouldReturnReceivedMessageCipherSSL":
case "ThenSubscribeShouldReturnReceivedMessageSecret":
case "ThenSubscribeShouldReturnReceivedMessageSecretSSL":
case "ThenSubscribeShouldReturnReceivedMessageSecretCipher":
case "ThenSubscribeShouldReturnReceivedMessageSecretCipherSSL":
case "ThenSubscribeShouldReturnReceivedMessageCipher":
case "ThenSubscribeShouldReturnEmojiMessage":
case "ThenSubscribeShouldReturnEmojiMessageSSL":
case "ThenSubscribeShouldReturnEmojiMessageSecret":
case "ThenSubscribeShouldReturnEmojiMessageCipherSecret":
case "ThenSubscribeShouldReturnEmojiMessageCipherSecretSSL":
case "ThenSubscribeShouldReturnEmojiMessageSecretSSL":
receivedMessage = true;
break;
default:
break;
}
}
else
{
Debug.WriteLine("Publish ErrorData: " + status.ErrorData?.Information);
}
publishManualEvent.Set();
}
public override void OnResponse(PNChannelGroupsAddChannelResult result, PNStatus status)
{
try
{
Console.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
if (result != null)
{
Console.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
//if (status.StatusCode == 200 && result.Message.ToLower() == "ok" && result.Service == "channel-registry"&& status.Error == false && result.ChannelGroup.Substring(1) == channelGroupName)
if (status.StatusCode == 200 && status.Error == false)
{
receivedChannelGroupMessage = true;
}
}
}
catch
{
}
finally
{
channelGroupManualEvent.Set();
}
}
}
Initialized = true;
InitializedChanged?.Invoke(Initialized);
}
public void Uninitialize()
{
// this can be called before Initialize
if (_Pubnub == null) return;
try
{
System.Diagnostics.Debug.WriteLine($"*** {GetType().Name}.Uninitialize - Uninitializing Chat for user {_UserId}");
_Pubnub.RemoveListener(_ListenerSubscribeCallack);
_Pubnub.Unsubscribe<string>().Channels(new string[] { _UserId }).Execute();
// TODO: consider removing push channel association here
Initialized = false;
InitializedChanged?.Invoke(Initialized);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"{ GetType().Name}.Uninitialize - Exception: { ex}");
}
}
#endregion Init
#region Callbacks
private void OnMessageReceived(Pubnub pubnub, PNMessageResult<object> result)
{
try
{
MessageReceived?.Invoke(this, new MessageEventArgs(result.Message.ToString()));
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"*** {GetType().Name}.MessageReceived - Unable to deserialize message: { result.Message}\r\n\tException: { ex}");
}
}
private void OnPresenceReceived(Pubnub pubnub, PNPresenceEventResult result)
{
System.Diagnostics.Debug.WriteLine($"*** { GetType().Name}.OnPresenceReceived\r\n -> Event: { result.Event}");
{
// handle incoming presence data
if (result.Event.Equals("join"))
{
RaiseChannelJoined(result.Channel, result.Uuid);
}
else if (result.Event.Equals("leave"))
{
RaiseChannelLeft(result.Channel, result.Uuid);
}
else if (result.Event.Equals("state-change"))
{
// listen for status events - eg: typing, etc
if ((result.State == null) || (result.State.Count == 0)) return;
foreach (var key in result.State.Keys)
{
var state = (ChatState)Enum.Parse(typeof(ChatState), result.State[key].ToString());
RaiseChannelState(result.Channel, result.Uuid, state);
}
}
else if (result.Event.Equals("timeout"))
{
}
else if (result.Event.Equals("interval"))
{
// find the ids that have joined
if ((result.Join != null) && (result.Join.Length > 0))
{
foreach (var uuid in result.Join) RaiseChannelJoined(result.Channel, uuid);
}
if ((result.Leave != null) && (result.Leave.Length > 0))
{
foreach (var uuid in result.Leave) RaiseChannelJoined(result.Channel, uuid);
}
}
else if (result.HereNowRefresh)
{
// TODO: request state for channels
//GetState();
}
}
}
private void OnStatusReceived(Pubnub pubnub, PNStatus status)
{
{
System.Diagnostics.Debug.WriteLine($"*** {GetType().Name}.OnStatusReceived\r\n -> Operation: { status.Operation}\r\n -> Category: { status.Category}\r\n -> Error: { status.Error}\r\n -> Data: { status.ErrorData}\r\n -> Status Code: { status.StatusCode}");
if (status.Operation == PNOperationType.PNHeartbeatOperation)
{
Connected = !status.Error;
ConnectedChanged?.Invoke(this, new EventArgs());
}
if ((status.Operation == PNOperationType.PNSubscribeOperation) && (status.Category == PNStatusCategory.PNUnknownCategory) && (status.StatusCode == 404))
{
try
{
_FailCount++;
if (_FailCount > 3)
{
System.Diagnostics.Debug.WriteLine($" -> Not found error, max fails = {_FailCount}");
return;
}
System.Diagnostics.Debug.WriteLine(" -> Not found error, attempting to reinitialize");
// disconnect
//System.Diagnostics.Debug.WriteLine(" -> -> uninitialize");
//Uninitialize();
// reconnect
System.Diagnostics.Debug.WriteLine(" -> -> reinitialize");
Initialize(_UserId, _AuthKey, false, _PushData);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("*** ChatService.Initialize - Exception: {0}", ex));
}
}
if (status.Category == PNStatusCategory.PNConnectedCategory)
{
System.Diagnostics.Debug.WriteLine(" -> Connected");
// this is expected for a subscribe, this means there is no error or issue whatsoever
// reset fail count
_FailCount = 0;
}
else if (status.Category == PNStatusCategory.PNReconnectedCategory)
{
System.Diagnostics.Debug.WriteLine(" -> Reconnected");
// this usually occurs if subscribe temporarily fails but reconnects. This means
// there was an error but there is no longer any issue
}
else if (status.Category == PNStatusCategory.PNDisconnectedCategory)
{
System.Diagnostics.Debug.WriteLine(" -> Disconnected");
// this is the expected category for an unsubscribe. This means there
// was no error in unsubscribing from everything
}
else if (status.Category == PNStatusCategory.PNUnexpectedDisconnectCategory)
{
System.Diagnostics.Debug.WriteLine(" -> Unexpected disconnected");
// this is usually an issue with the internet connection, this is an error, handle appropriately
}
else if (status.Category == PNStatusCategory.PNAccessDeniedCategory)
{
System.Diagnostics.Debug.WriteLine(" -> Access Denied");
// this means that PAM does allow this client to subscribe to this
// channel and channel group configuration. This is another explicit error
}
}
}
#endregion Callbacks
#region Operations
public void GetHistory(long timeStamp)
{
try
{
if (!Initialized || string.IsNullOrEmpty(_UserId)) return;
_Pubnub.History()
.Channel(_UserId)
.Start(timeStamp)
.Count(20)
.Async(new PNHistoryResultExt((result, status) =>
{
if ((result.Messages == null) || (result.Messages.Count == 0)) return;
foreach (var message in result.Messages)
{
// let listeners know
MessageReceived?.Invoke(this, new MessageEventArgs(message.Entry.ToString()));
}
}));
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("*** ChatService.GetHistory - Exception: {0}", ex));
}
}
public void Publish(string to, string message, object state)
{
try
{
if (!Initialized || string.IsNullOrEmpty(_UserId)) throw new ArgumentException("Cannot publish before initialize.");
// publish message
_Pubnub.Publish()
.Channel(to)
.Message(message)
.Async(new PNPublishResultExt((result, status) =>
{
if (message == null) return;
// get the message
PublishComplete?.Invoke(this, new MessageEventArgs(message)
{
State = state,
Success = !status.Error,
Timestamp = new DateTime(result.Timetoken)
});
}));
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("*** ChatService.Publish - Exception: {0}", ex));
}
}
#endregion Operations
#region Event Triggers
private void RaiseChannelJoined(string channel, string uuid)
{
ChannelJoined?.Invoke(this, new PresenceEventArgs(channel, uuid));
}
private void RaiseChannelLeft(string channel, string uuid)
{
ChannelLeft?.Invoke(this, new PresenceEventArgs(channel, uuid));
}
private void RaiseChannelTimeout(string channel, string uuid)
{
ChannelTimeout?.Invoke(this, new PresenceEventArgs(channel, uuid));
}
private void RaiseChannelState(string channel, string uuid, ChatState state)
{
ChannelState?.Invoke(this, new PresenceEventArgs(channel, uuid, state));
}
#endregion Event Triggers
#region Cleanup
public void Dispose()
{
if (_Disposed) return;
// TODO: check this - it looks dodgy
SubscribeCallbackExt listenerSubscribeCallack = new SubscribeCallbackExt((pubnubObj, message) => { }, (pubnubObj, presence) => { }, (pubnubObj, status) => { });
_Pubnub.AddListener(listenerSubscribeCallack);
// some time later
_Pubnub.RemoveListener(listenerSubscribeCallack);
_Pubnub.Destroy();
_Disposed = true;
}
#endregion Cleanup
}
}
public override void OnResponse(PNPublishResult result, PNStatus status)
{
SyncResult = result;
syncEvent.Set();
}
private async Task <PNResult <PNChannelMembersResult> > ProcessMembersOperationRequest(string channel, List <PNChannelMember> setMemberList, List <string> removeMemberList, PNPageObject page, int limit, bool includeCount, string includeOptions, List <string> sort, Dictionary <string, object> externalQueryParam)
{
PNResult <PNChannelMembersResult> ret = new PNResult <PNChannelMembersResult>();
if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()))
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Missing Channel", new ArgumentException("Missing Channel"))
};
ret.Status = errStatus;
return(ret);
}
if (string.IsNullOrEmpty(config.SubscribeKey) || string.IsNullOrEmpty(config.SubscribeKey.Trim()) || config.SubscribeKey.Length <= 0)
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid Subscribe key", new ArgumentException("Invalid Subscribe key"))
};
ret.Status = errStatus;
return(ret);
}
PNPageObject internalPage;
if (page == null)
{
internalPage = new PNPageObject();
}
else
{
internalPage = page;
}
RequestState <PNChannelMembersResult> requestState = new RequestState <PNChannelMembersResult>();
requestState.ResponseType = PNOperationType.PNManageChannelMembersOperation;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
requestState.UsePatchMethod = true;
requestState.UsePatchMethod = true;
Dictionary <string, object> messageEnvelope = new Dictionary <string, object>();
if (setMemberList != null)
{
List <Dictionary <string, object> > setMemberFormatList = new List <Dictionary <string, object> >();
for (int index = 0; index < setMemberList.Count; index++)
{
Dictionary <string, object> currentMemberFormat = new Dictionary <string, object>();
currentMemberFormat.Add("uuid", new Dictionary <string, string> {
{ "id", setMemberList[index].Uuid }
});
if (setMemberList[index].Custom != null)
{
currentMemberFormat.Add("custom", setMemberList[index].Custom);
}
setMemberFormatList.Add(currentMemberFormat);
}
if (setMemberFormatList.Count > 0)
{
messageEnvelope.Add("set", setMemberFormatList);
}
}
if (removeMemberList != null)
{
List <Dictionary <string, Dictionary <string, string> > > removeMemberFormatList = new List <Dictionary <string, Dictionary <string, string> > >();
for (int index = 0; index < removeMemberList.Count; index++)
{
Dictionary <string, Dictionary <string, string> > currentMemberFormat = new Dictionary <string, Dictionary <string, string> >();
if (!string.IsNullOrEmpty(removeMemberList[index]))
{
currentMemberFormat.Add("uuid", new Dictionary <string, string> {
{ "id", removeMemberList[index] }
});
removeMemberFormatList.Add(currentMemberFormat);
}
}
if (removeMemberFormatList.Count > 0)
{
messageEnvelope.Add("delete", removeMemberFormatList);
}
}
string patchMessage = jsonLibrary.SerializeToJsonString(messageEnvelope);
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildMemberAddUpdateRemoveChannelRequest("PATCH", patchMessage, channel, internalPage.Next, internalPage.Prev, limit, includeCount, includeOptions, sort, externalQueryParam);
Tuple <string, PNStatus> JsonAndStatusTuple = await UrlProcessRequest(request, requestState, false, patchMessage).ConfigureAwait(false);
ret.Status = JsonAndStatusTuple.Item2;
string json = JsonAndStatusTuple.Item1;
if (!string.IsNullOrEmpty(json))
{
List <object> resultList = ProcessJsonResponse(requestState, json);
ResponseBuilder responseBuilder = new ResponseBuilder(config, jsonLibrary, pubnubLog);
PNChannelMembersResult responseResult = responseBuilder.JsonToObject <PNChannelMembersResult>(resultList, true);
if (responseResult != null)
{
ret.Result = responseResult;
}
}
return(ret);
}
internal void SetUserState(string[] channels, string[] channelGroups, string uuid, string jsonUserState, PNCallback <PNSetStateResult> callback)
{
if ((channels == null && channelGroups == null) ||
(channels != null && channelGroups != null && channels.Length == 0 && channelGroups.Length == 0))
{
throw new ArgumentException("Either Channel Or Channel Group or Both should be provided");
}
if (string.IsNullOrEmpty(jsonUserState) || string.IsNullOrEmpty(jsonUserState.Trim()))
{
throw new ArgumentException("Missing User State");
}
List <string> channelList = new List <string>();
List <string> channelGroupList = new List <string>();
if (channels != null && channels.Length > 0)
{
channelList = new List <string>(channels);
channelList = channelList.Where(ch => !string.IsNullOrEmpty(ch) && ch.Trim().Length > 0).Distinct <string>().ToList();
channels = channelList.ToArray();
}
if (channelGroups != null && channelGroups.Length > 0)
{
channelGroupList = new List <string>(channelGroups);
channelGroupList = channelGroupList.Where(cg => !string.IsNullOrEmpty(cg) && cg.Trim().Length > 0).Distinct <string>().ToList();
channelGroups = channelGroupList.ToArray();
}
string commaDelimitedChannel = (channels != null && channels.Length > 0) ? string.Join(",", channels.OrderBy(x => x).ToArray()) : "";
string commaDelimitedChannelGroup = (channelGroups != null && channelGroups.Length > 0) ? string.Join(",", channelGroups.OrderBy(x => x).ToArray()) : "";
if (!jsonLibrary.IsDictionaryCompatible(jsonUserState))
{
throw new MissingMemberException("Missing json format for user state");
}
else
{
Dictionary <string, object> deserializeUserState = jsonLibrary.DeserializeToDictionaryOfObject(jsonUserState);
if (deserializeUserState == null)
{
throw new MissingMemberException("Missing json format user state");
}
else
{
bool stateChanged = false;
for (int channelIndex = 0; channelIndex < channelList.Count; channelIndex++)
{
string currentChannel = channelList[channelIndex];
string oldJsonChannelState = GetLocalUserState(currentChannel, "");
if (oldJsonChannelState != jsonUserState)
{
stateChanged = true;
break;
}
}
if (!stateChanged)
{
for (int channelGroupIndex = 0; channelGroupIndex < channelGroupList.Count; channelGroupIndex++)
{
string currentChannelGroup = channelGroupList[channelGroupIndex];
string oldJsonChannelGroupState = GetLocalUserState("", currentChannelGroup);
if (oldJsonChannelGroupState != jsonUserState)
{
stateChanged = true;
break;
}
}
}
if (!stateChanged)
{
StatusBuilder statusBuilder = new StatusBuilder(config, jsonLibrary);
PNStatus status = statusBuilder.CreateStatusResponse <PNSetStateResult>(PNOperationType.PNSetStateOperation, PNStatusCategory.PNUnknownCategory, null, (int)System.Net.HttpStatusCode.NotModified, null);
Announce(status);
return;
}
}
}
SharedSetUserState(channels, channelGroups, uuid, jsonUserState, jsonUserState, callback);
}
private async Task <PNResult <PNPublishResult> > Signal(string channel, object message, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam)
{
PNResult <PNPublishResult> ret = new PNResult <PNPublishResult>();
if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null)
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message"))
};
ret.Status = errStatus;
return(ret);
}
if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0)
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid publish key", new ArgumentException("Invalid publish key"))
};
ret.Status = errStatus;
return(ret);
}
if (string.IsNullOrEmpty(config.SubscribeKey) || string.IsNullOrEmpty(config.SubscribeKey.Trim()) || config.SubscribeKey.Length <= 0)
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid subscribe key", new ArgumentException("Invalid subscribe key"))
};
ret.Status = errStatus;
return(ret);
}
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildSignalRequest("GET", "", channel, message, metaData, externalQueryParam);
RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>();
requestState.Channels = new[] { channel };
requestState.ResponseType = PNOperationType.PNSignalOperation;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
Tuple <string, PNStatus> JsonAndStatusTuple = await UrlProcessRequest(request, requestState, false).ConfigureAwait(false);
ret.Status = JsonAndStatusTuple.Item2;
string json = JsonAndStatusTuple.Item1;
if (!string.IsNullOrEmpty(json))
{
List <object> result = ProcessJsonResponse <PNPublishResult>(requestState, json);
if (result != null && result.Count >= 3)
{
int publishStatus;
Int32.TryParse(result[0].ToString(), out publishStatus);
if (publishStatus == 1)
{
List <object> resultList = ProcessJsonResponse(requestState, json);
if (resultList != null && resultList.Count > 0)
{
ResponseBuilder responseBuilder = new ResponseBuilder(config, jsonLibrary, pubnubLog);
PNPublishResult responseResult = responseBuilder.JsonToObject <PNPublishResult>(resultList, true);
if (responseResult != null)
{
ret.Result = responseResult;
}
}
else
{
PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString());
PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNSignalOperation, category, requestState, 400, new PNException(json));
ret.Status = status;
ret.Result = default(PNPublishResult);
}
}
}
}
return(ret);
}
private void Signal(string channel, object message, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam, PNCallback <PNPublishResult> callback)
{
if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null)
{
PNStatus status = new PNStatus {
Error = true, ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message"))
};
callback.OnResponse(null, status);
return;
}
if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0)
{
PNStatus status = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid publish key", new ArgumentException("Invalid publish key"))
};
callback.OnResponse(null, status);
return;
}
if (string.IsNullOrEmpty(config.SubscribeKey) || string.IsNullOrEmpty(config.SubscribeKey.Trim()) || config.SubscribeKey.Length <= 0)
{
PNStatus status = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid subscribe key", new ArgumentException("Invalid subscribe key"))
};
callback.OnResponse(null, status);
return;
}
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildSignalRequest("GET", "", channel, message, metaData, externalQueryParam);
RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>();
requestState.Channels = new[] { channel };
requestState.ResponseType = PNOperationType.PNSignalOperation;
requestState.PubnubCallback = callback;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
UrlProcessRequest(request, requestState, false).ContinueWith(r =>
{
string json = r.Result.Item1;
if (!string.IsNullOrEmpty(json))
{
List <object> result = ProcessJsonResponse(requestState, json);
if (result != null && result.Count >= 3)
{
int signalStatus;
Int32.TryParse(result[0].ToString(), out signalStatus);
if (signalStatus == 1)
{
ProcessResponseCallbacks(result, requestState);
}
else
{
PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString());
PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNSignalOperation, category, requestState, 400, new PNException(json));
if (requestState.PubnubCallback != null)
{
requestState.PubnubCallback.OnResponse(default(PNPublishResult), status);
}
}
}
else
{
ProcessResponseCallbacks(result, requestState);
}
}
}, TaskContinuationOptions.ExecuteSynchronously).Wait();
}
