public static PNStatusCategory GetPNStatusCategory(WebExceptionStatus webExceptionStatus, string webExceptionMessage)
{
PNStatusCategory ret = PNStatusCategory.PNUnknownCategory;
switch (webExceptionStatus)
{
case WebExceptionStatus.RequestCanceled:
ret = PNStatusCategory.PNCancelledCategory;
break;
case WebExceptionStatus.ConnectFailure:
case WebExceptionStatus.SendFailure:
case WebExceptionStatus.Pending:
case WebExceptionStatus.Success:
ret = PNStatusCategory.PNNetworkIssuesCategory;
break;
default:
if (string.Compare(webExceptionStatus.ToString(), "SecureChannelFailure", StringComparison.CurrentCultureIgnoreCase) == 0 ||
string.Compare(webExceptionStatus.ToString(), "NameResolutionFailure", StringComparison.CurrentCultureIgnoreCase) == 0)
{
ret = PNStatusCategory.PNNetworkIssuesCategory;
}
else
{
Debug.WriteLine("ATTENTION: webExceptionStatus = " + webExceptionStatus.ToString());
}
break;
}
return(ret);
}
public static PNStatus CreatePNStatus(PNStatusCategory category, string errorString, Exception errorException, bool error, PNOperationType operation, ChannelEntity channelEntity, RequestState pnRequestState, PubNubUnity pnUnity)
{
PNErrorData errorData = null;
if ((!string.IsNullOrEmpty(errorString)) || (errorException != null))
{
errorData = new PNErrorData();
errorData.Info = errorString;
errorData.Ex = errorException;
}
List <string> affectedChannels = null;
List <string> affectedChannelGroups = null;
if (channelEntity.ChannelID.IsChannelGroup)
{
affectedChannelGroups = new List <string>();
affectedChannelGroups.Add(channelEntity.ChannelID.ChannelOrChannelGroupName);
}
else
{
affectedChannels = new List <string>();
affectedChannels.Add(channelEntity.ChannelID.ChannelOrChannelGroupName);
}
return(CreatePNStatus(category, errorData, error, operation, affectedChannels, affectedChannelGroups, pnRequestState, pnUnity));
}
private void RaiseConnectionStatusResponse(bool isError, PNStatusCategory category, Action <ConnectionStatusEventData> callback, Exception exception = null)
{
connectionStatusEventData = new ConnectionStatusEventData(EventSystem.current);
connectionStatusEventData.Initialize(isError, category, exception);
callback(connectionStatusEventData);
}
public static PNStatus CreatePNStatus(PNStatusCategory category, string errorString, Exception errorException, bool error, PNOperationType operation, List <ChannelEntity> affectedChannels, List <ChannelEntity> affectedChannelGroups, RequestState pnRequestState, PubNubUnity pnUnity)
{
PNErrorData errorData = CreateErrorData(errorString, errorException);
List <string> channels = CreateListOfStringFromListOfChannelEntity(affectedChannels);
List <string> channelGroups = CreateListOfStringFromListOfChannelEntity(affectedChannelGroups);
return(CreatePNStatus(category, errorData, error, operation, channels, channelGroups, pnRequestState, pnUnity));
}
internal static PNStatus CreatePNStatus(PNStatusCategory category, PNErrorData errorData, bool error, PNOperationType operation, List <string> channels, List <string> channelGroups, RequestState pnRequestState, PubNubUnity pnUnity)
{
long statusCode = 0;
string url = "";
if (pnRequestState != null)
{
statusCode = pnRequestState.ResponseCode;
url = pnRequestState.URL;
}
PNStatus pnStatus = new PNStatus(
category,
errorData,
error,
statusCode,
operation,
pnUnity.PNConfig.Secure,
pnUnity.PNConfig.UUID,
pnUnity.PNConfig.AuthKey,
pnUnity.PNConfig.Origin,
channels,
channelGroups,
url
);
#if (ENABLE_PUBNUB_LOGGING)
pnUnity.PNLog.WriteToLog(string.Format("CreatePNStatus: \n" +
"category={0} \n" +
"errorData={1} \n" +
"error={2} \n" +
"statusCode={3} \n" +
"operation={4} \n" +
"tlsEnabled={5} \n" +
"uuid={6} \n" +
"authKey={7} \n" +
"origin={8} \n" +
"channels={9} \n" +
"channelGroups={10} \n" +
"clientRequest={11} \n",
category.ToString(),
((errorData != null) && (errorData.Ex != null)) ? errorData.Ex.ToString() : "null",
error.ToString(),
statusCode.ToString(),
operation.ToString(),
pnUnity.PNConfig.Secure,
pnUnity.PNConfig.UUID,
pnUnity.PNConfig.AuthKey,
pnUnity.PNConfig.Origin,
(channels != null) ? string.Join(",", channels.ToArray()) : "null",
(channelGroups != null) ? string.Join(",", channelGroups.ToArray()) : "null",
url
), PNLoggingMethod.LevelInfo);
#endif
return(pnStatus);
}
private void RaiseConnectionStatusResponse(bool isError, PNStatusCategory category, Action<ConnectionStatusEventData> callback, Exception exception = null)
{
Debug.Log(displayName + "1");
connectionStatusEventData = new ConnectionStatusEventData(EventSystem.current);
Debug.Log(displayName + "2");
connectionStatusEventData.Initialize(isError, category, exception);
Debug.Log(displayName + "3");
//callback(connectionStatusEventData);
}
private void PubnubStatusCategoryLogger(PNStatusCategory category)
{
bool isError = false;
switch (category)
{
case PNStatusCategory.PNNetworkIssuesCategory:
break;
case PNStatusCategory.PNReconnectedCategory:
break;
case PNStatusCategory.PNConnectedCategory:
PubnubCatchUp();
break;
case PNStatusCategory.PNAccessDeniedCategory:
break;
case PNStatusCategory.PNAcknowledgmentCategory:
break;
case PNStatusCategory.PNTimeoutCategory:
break;
case PNStatusCategory.PNDisconnectedCategory:
break;
case PNStatusCategory.PNUnexpectedDisconnectCategory:
break;
case PNStatusCategory.PNBadRequestCategory:
break;
case PNStatusCategory.PNMalformedFilterExpressionCategory:
break;
case PNStatusCategory.PNMalformedResponseCategory:
break;
case PNStatusCategory.PNDecryptionErrorCategory:
break;
case PNStatusCategory.PNTLSConnectionFailedCategory:
break;
case PNStatusCategory.PNRequestMessageCountExceededCategory:
break;
}
RaiseConnectionStatusResponse(isError, category, handleConnectionStatusCallback);
}
private static void ParseCheckSocketConnectException <T>(Exception ex, PNOperationType type, PNCallback <T> callback, Action <bool> internalcallback)
{
PNStatusCategory errorCategory = PNStatusCategoryHelper.GetPNStatusCategory(ex);
StatusBuilder statusBuilder = new StatusBuilder(pubnubConfig, jsonLib);
PNStatus status = statusBuilder.CreateStatusResponse <T>(type, errorCategory, null, (int)System.Net.HttpStatusCode.NotFound, new PNException(ex));
if (callback != null)
{
callback.OnResponse(default(T), status);
}
LoggingMethod.WriteToLog(pubnubLog, string.Format("DateTime {0} ParseCheckSocketConnectException Error. {1}", DateTime.Now.ToString(CultureInfo.InvariantCulture), ex.Message), pubnubConfig.LogVerbosity);
internalcallback(false);
}
private void RaiseConnectionStatusResponse(bool isError, PNStatusCategory category, Action <ConnectionStatusEventData> callback, Exception exception = null)
{
connectionStatusEventData = new ConnectionStatusEventData(EventSystem.current);
connectionStatusEventData.Initialize(isError, category, exception);
if (callback == null)
{
log("connectionStatusCallback not implemented!");
}
else
{
callback(connectionStatusEventData);
}
}
public PNStatus(PNStatusCategory category, PNErrorData errorData, bool error, long statusCode, PNOperationType operation, bool tlsEnabled, string uuid, string authKey, string origin, List <String> affectedChannels, List <String> affectedChannelGroups, object clientRequest)
{
this.Category = category;
this.ErrorData = errorData;
this.Error = error;
this.StatusCode = statusCode;
this.Operation = operation;
this.TlsEnabled = tlsEnabled;
this.UUID = uuid;
this.AuthKey = authKey;
this.Origin = origin;
this.ClientRequest = clientRequest;
this.AffectedChannelGroups = affectedChannelGroups;
this.AffectedChannels = affectedChannels;
}
protected void CreateErrorResponse(PNStatusCategory pnStatusCategory, Exception exception, bool showInCallback, RequestState pnRequestState)
{
PNStatus pnStatus = Helpers.CreatePNStatus(
pnStatusCategory,
exception.Message,
exception,
true,
OperationType,
ChannelsToUse,
ChannelGroupsToUse,
pnRequestState,
PubNubInstance
);
if (showInCallback)
{
Callback(null, pnStatus);
}
}
protected void OnPubnubWebRequestTimeout <T>(System.Object requestState)
{
RequestState <T> currentState = requestState as RequestState <T>;
if (currentState != null && currentState.Response == null && currentState.Request != null)
{
currentState.Timeout = true;
try
{
currentState.Request.Abort();
}
catch { /* ignore */ }
LoggingMethod.WriteToLog(pubnubLog, string.Format("DateTime: {0}, **WP7 OnPubnubWebRequestTimeout**", DateTime.Now.ToString(CultureInfo.InvariantCulture)), pubnubConfig.LogVerbosity);
if (currentState.ResponseType != PNOperationType.PNSubscribeOperation &&
currentState.ResponseType != PNOperationType.Presence &&
currentState.ResponseType != PNOperationType.PNHeartbeatOperation &&
currentState.ResponseType != PNOperationType.Leave)
{
PNStatusCategory errorCategory = PNStatusCategory.PNTimeoutCategory;
PNStatus status = new StatusBuilder(pubnubConfig, jsonLib).CreateStatusResponse <T>(currentState.ResponseType, errorCategory, currentState, (int)HttpStatusCode.NotFound, new PNException("Request timeout"));
if (currentState.Channels != null && currentState.Channels.Length > 0)
{
status.AffectedChannels.AddRange(currentState.Channels);
}
if (currentState.ChannelGroups != null && currentState.ChannelGroups.Length > 0)
{
status.AffectedChannels.AddRange(currentState.ChannelGroups);
}
if (currentState.PubnubCallback != null)
{
currentState.PubnubCallback.OnResponse(default(T), status);
}
}
}
}
public static PNStatusCategory GetPNStatusCategory(Exception ex)
{
PNStatusCategory ret = PNStatusCategory.PNUnknownCategory;
if (ex == null)
{
return(ret);
}
string errorType = ex.GetType().ToString();
string errorMessage = ex.Message;
if (errorType == "System.FormatException" && errorMessage == "Invalid length for a Base-64 char array or string.")
{
ret = PNStatusCategory.PNDecryptionErrorCategory;
}
else if (errorType == "System.FormatException" && errorMessage == "The input is not a valid Base-64 string as it contains a non-base 64 character, more than two padding characters, or an illegal character among the padding characters. ")
{
ret = PNStatusCategory.PNDecryptionErrorCategory;
}
else if (errorType == "System.ObjectDisposedException" && errorMessage == "Cannot access a disposed object.")
{
ret = PNStatusCategory.PNUnknownCategory;
}
else if (errorType == "System.Net.Sockets.SocketException" && errorMessage == "The requested name is valid, but no data of the requested type was found")
{
ret = PNStatusCategory.PNNetworkIssuesCategory;
}
else if (errorType == "System.Net.Sockets.SocketException" && errorMessage == "No such host is known")
{
ret = PNStatusCategory.PNNetworkIssuesCategory;
}
else if (errorType == "System.Security.Cryptography.CryptographicException" && errorMessage == "Padding is invalid and cannot be removed.")
{
ret = PNStatusCategory.PNDecryptionErrorCategory;
}
else if (errorType == "System.Runtime.InteropServices.SEHException" && errorMessage == "External component has thrown an exception.")
{
ret = PNStatusCategory.PNUnknownCategory;
}
else if (errorType == "System.Net.WebException" && errorMessage.Contains("The remote name could not be resolved:"))
{
ret = PNStatusCategory.PNNetworkIssuesCategory;
}
else if (errorType == "System.Net.WebException" && errorMessage.Contains("Unable to connect to the remote server"))
{
ret = PNStatusCategory.PNNetworkIssuesCategory;
}
else if (errorType == "System.Net.WebException" && errorMessage.Contains("Unable to read data from the transport connection"))
{
ret = PNStatusCategory.PNNetworkIssuesCategory;
}
else if (errorType == "System.Net.WebException" && errorMessage.Contains("SecureChannelFailure"))
{
ret = PNStatusCategory.PNNetworkIssuesCategory;
}
else if (errorType == "System.Net.WebException" && errorMessage.Contains("ConnectFailure"))
{
ret = PNStatusCategory.PNNetworkIssuesCategory;
}
else if (errorType == "System.Net.WebException" && errorMessage.Contains("ReceiveFailure"))
{
ret = PNStatusCategory.PNNetworkIssuesCategory;
}
else if (errorType == "System.Net.WebException" && errorMessage.Contains("SendFailure"))
{
ret = PNStatusCategory.PNNetworkIssuesCategory;
}
else if (errorType == "System.ArgumentException" && errorMessage.Contains("cannot be converted to type"))
{
ret = PNStatusCategory.PNMalformedResponseCategory;
}
else if (errorMessage.Contains("Disconnected"))
{
ret = PNStatusCategory.PNDisconnectedCategory;
}
return(ret);
}
public static PNStatusCategory GetPNStatusCategory(int statusCode, string httpErrorCodeMessage)
{
PNStatusCategory ret = PNStatusCategory.PNUnknownCategory;
switch (statusCode)
{
case 400:
if (httpErrorCodeMessage.ToUpperInvariant().Contains("MESSAGE TOO LARGE"))
{
ret = PNStatusCategory.PNBadRequestCategory;
}
else if (httpErrorCodeMessage.ToUpperInvariant() == "INVALID KEY" || httpErrorCodeMessage.ToUpperInvariant() == "INVALID SUBSCRIBE KEY")
{
ret = PNStatusCategory.PNAccessDeniedCategory;
}
else if (httpErrorCodeMessage.ToUpperInvariant() == "BADREQUEST")
{
ret = PNStatusCategory.PNBadRequestCategory;
}
else if (httpErrorCodeMessage.ToUpperInvariant() == "NO UUID SPECIFIED")
{
ret = PNStatusCategory.PNBadRequestCategory;
}
else if (httpErrorCodeMessage.ToUpperInvariant() == "INVALID TIMESTAMP")
{
ret = PNStatusCategory.PNBadRequestCategory;
}
else if (httpErrorCodeMessage.ToUpperInvariant() == "INVALID TYPE ARGUMENT")
{
ret = PNStatusCategory.PNBadRequestCategory;
}
else if (httpErrorCodeMessage.ToUpperInvariant() == "CHANNEL GROUP OR GROUPS RESULT IN EMPTY SUBSCRIPTION SET")
{
ret = PNStatusCategory.PNBadRequestCategory;
}
else if (httpErrorCodeMessage.ToUpperInvariant() == "COULD NOT PARSE REQUEST")
{
ret = PNStatusCategory.PNBadRequestCategory;
}
break;
case 401:
ret = PNStatusCategory.PNAccessDeniedCategory;
break;
case 402:
if (httpErrorCodeMessage.ToUpperInvariant() == "NOT ENABLED")
{
ret = PNStatusCategory.PNAccessDeniedCategory;
}
break;
case 403:
if (httpErrorCodeMessage.ToUpperInvariant() == "FORBIDDEN")
{
ret = PNStatusCategory.PNAccessDeniedCategory;
}
else if (httpErrorCodeMessage.ToUpperInvariant() == "SIGNATURE DOES NOT MATCH")
{
ret = PNStatusCategory.PNAccessDeniedCategory;
}
break;
case 404:
case 414:
case 500:
ret = PNStatusCategory.PNBadRequestCategory;
break;
case 502:
case 503:
case 504:
ret = PNStatusCategory.PNNetworkIssuesCategory;
break;
default:
ret = PNStatusCategory.PNUnknownCategory;
break;
}
return(ret);
}
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();
}
public List <object> DecodeDecryptLoop <T>(List <object> message, string[] channels, string[] channelGroups, PNCallback <T> errorCallback)
{
List <object> returnMessage = new List <object>();
if (config.CipherKey.Length > 0)
{
PubnubCrypto aes = new PubnubCrypto(config.CipherKey, config, pubnubLog);
object[] myObjectArray = (from item in message
select item as object).ToArray();
object[] enumerable = myObjectArray[0] as object[];
if (enumerable != null)
{
List <object> receivedMsg = new List <object>();
foreach (object element in enumerable)
{
string decryptMessage = "";
try
{
Dictionary <string, object> historyEnv = jsonLib.ConvertToDictionaryObject(element);
if (historyEnv != null && historyEnv.ContainsKey("message"))
{
string dictionaryValue = aes.Decrypt(historyEnv["message"].ToString());
historyEnv["message"] = jsonLib.DeserializeToObject(dictionaryValue);
decryptMessage = jsonLib.SerializeToJsonString(historyEnv);
}
else
{
decryptMessage = aes.Decrypt(element.ToString());
}
}
catch (Exception ex)
{
decryptMessage = "**DECRYPT ERROR**";
PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(ex);
PNStatus status = new StatusBuilder(config, jsonLib).CreateStatusResponse <T>(PNOperationType.PNHistoryOperation, category, null, (int)HttpStatusCode.NotFound, new PNException(ex));
if (channels != null && channels.Length > 0)
{
status.AffectedChannels.AddRange(channels);
}
if (channelGroups != null && channelGroups.Length > 0)
{
status.AffectedChannelGroups.AddRange(channelGroups);
}
errorCallback.OnResponse(default(T), status);
}
object decodeMessage = (decryptMessage == "**DECRYPT ERROR**") ? decryptMessage : jsonLib.DeserializeToObject(decryptMessage);
receivedMsg.Add(decodeMessage);
}
returnMessage.Add(receivedMsg);
}
for (int index = 1; index < myObjectArray.Length; index++)
{
returnMessage.Add(myObjectArray[index]);
}
return(returnMessage);
}
else
{
var myObjectArray = (from item in message
select item as object).ToArray();
IEnumerable enumerable = myObjectArray[0] as IEnumerable;
if (enumerable != null)
{
List <object> receivedMessage = new List <object>();
foreach (object element in enumerable)
{
receivedMessage.Add(element);
}
returnMessage.Add(receivedMessage);
}
for (int index = 1; index < myObjectArray.Length; index++)
{
returnMessage.Add(myObjectArray[index]);
}
return(returnMessage);
}
}
internal void RaiseError(PNStatusCategory pnStatusCategory, Exception exception, bool showInCallback, RequestState pnRequestState)
{
this.CreateErrorResponse(pnStatusCategory, exception, showInCallback, pnRequestState);
}
private void ProcessFileMessagePublish(Dictionary <string, object> externalQueryParam, PNCallback <PNPublishFileMessageResult> callback)
{
if (string.IsNullOrEmpty(this.channelName) || string.IsNullOrEmpty(this.channelName.Trim()))
{
PNStatus status = new PNStatus();
status.Error = true;
status.ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message"));
callback.OnResponse(null, status);
return;
}
Dictionary <string, object> publishPayload = new Dictionary <string, object>();
if (this.msg != null && !string.IsNullOrEmpty(this.msg.ToString()))
{
publishPayload.Add("message", this.msg);
}
publishPayload.Add("file", new Dictionary <string, string> {
{ "id", currentFileId },
{ "name", currentFileName }
});
RequestState <PNPublishFileMessageResult> requestState = new RequestState <PNPublishFileMessageResult>();
requestState.ResponseType = PNOperationType.PNPublishFileMessageOperation;
requestState.PubnubCallback = callback;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildPublishFileMessageRequest("GET", "", this.channelName, publishPayload, this.storeInHistory, this.ttl, this.userMetadata, null, externalQueryParam);
string json = "";
UrlProcessRequest(request, requestState, false).ContinueWith(r =>
{
json = r.Result.Item1;
}, TaskContinuationOptions.ExecuteSynchronously).Wait();
if (!string.IsNullOrEmpty(json))
{
List <object> result = ProcessJsonResponse(requestState, json);
if (result != null && result.Count >= 3)
{
int publishStatus;
Int32.TryParse(result[0].ToString(), out publishStatus);
if (publishStatus == 1)
{
ProcessResponseCallbacks(result, requestState);
}
else
{
PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString());
PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishFileMessageResult>(PNOperationType.PNPublishFileMessageOperation, category, requestState, 400, new PNException(json));
if (requestState.PubnubCallback != null)
{
requestState.PubnubCallback.OnResponse(default(PNPublishFileMessageResult), status);
}
}
}
else
{
ProcessResponseCallbacks(result, requestState);
}
}
}
private void Fire(string channel, object message, bool storeInHistory, int ttl, 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 (callback == null)
{
return;
}
Dictionary <string, string> urlParam = new Dictionary <string, string>();
urlParam.Add("norep", "true");
string requestMethodName = (this.httpPost) ? "POST" : "GET";
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildPublishRequest(requestMethodName, "", channel, message, storeInHistory, ttl, metaData, urlParam, externalQueryParam);
RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>();
requestState.Channels = new [] { channel };
requestState.ResponseType = PNOperationType.PNFireOperation;
requestState.PubnubCallback = callback;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
string json = "";
if (this.httpPost)
{
requestState.UsePostMethod = true;
Dictionary <string, object> messageEnvelope = new Dictionary <string, object>();
messageEnvelope.Add("message", message);
string postMessage = jsonLibrary.SerializeToJsonString(messageEnvelope);
UrlProcessRequest(request, requestState, false, postMessage).ContinueWith(r =>
{
json = r.Result.Item1;
}, TaskContinuationOptions.ExecuteSynchronously).Wait();
}
else
{
UrlProcessRequest(request, requestState, false).ContinueWith(r =>
{
json = r.Result.Item1;
}, TaskContinuationOptions.ExecuteSynchronously).Wait();
}
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)
{
ProcessResponseCallbacks(result, requestState);
}
else
{
PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString());
PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNFireOperation, category, requestState, 400, new PNException(json));
if (requestState.PubnubCallback != null)
{
requestState.PubnubCallback.OnResponse(default(PNPublishResult), status);
}
}
}
else
{
ProcessResponseCallbacks(result, requestState);
}
}
}
public List <object> FetchHistoryDecodeDecryptLoop <T>(PNOperationType type, Dictionary <string, object> messageContainer, string[] channels, string[] channelGroups, PNCallback <T> errorCallback)
{
List <object> returnMessage = new List <object>();
Dictionary <string, List <object> > dicMessage = new Dictionary <string, List <object> >();
foreach (KeyValuePair <string, object> kvp in messageContainer)
{
List <object> currentVal = kvp.Value as List <object>;
if (currentVal != null)
{
object[] currentValArray = jsonLib.ConvertToObjectArray(currentVal);
List <object> decryptList = (currentValArray != null && currentValArray.Length > 0) ? new List <object>() : null;
if (currentValArray != null && decryptList != null)
{
foreach (object currentObj in currentValArray)
{
Dictionary <string, object> dicValue = jsonLib.ConvertToDictionaryObject(currentObj);
if (dicValue != null && dicValue.Count > 0 && dicValue.ContainsKey("message"))
{
Dictionary <string, object> dicDecrypt = new Dictionary <string, object>();
foreach (KeyValuePair <string, object> kvpValue in dicValue)
{
if (kvpValue.Key == "message" && config.CipherKey.Length > 0)
{
PubnubCrypto aes = new PubnubCrypto(config.CipherKey, config, pubnubLog);
string decryptMessage = "";
try
{
decryptMessage = aes.Decrypt(kvpValue.Value.ToString());
}
catch (Exception ex)
{
#region "Exception"
decryptMessage = "**DECRYPT ERROR**";
PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(ex);
PNStatus status = new StatusBuilder(config, jsonLib).CreateStatusResponse <T>(type, category, null, (int)HttpStatusCode.NotFound, new PNException(ex));
if (channels != null && channels.Length > 0)
{
status.AffectedChannels.AddRange(channels);
}
if (channelGroups != null && channelGroups.Length > 0)
{
status.AffectedChannelGroups.AddRange(channelGroups);
}
errorCallback.OnResponse(default(T), status);
#endregion
}
object decodeMessage = (decryptMessage == "**DECRYPT ERROR**") ? decryptMessage : jsonLib.DeserializeToObject(decryptMessage);
dicDecrypt.Add(kvpValue.Key, decodeMessage);
}
else
{
dicDecrypt.Add(kvpValue.Key, kvpValue.Value);
}
}
decryptList.Add(dicDecrypt);
}
}
}
dicMessage.Add(kvp.Key, decryptList);
}
}
if (dicMessage.Count > 0)
{
returnMessage.Add(dicMessage);
}
return(returnMessage);
}
protected PNStatus CreateStatusResponseFromMessage(bool isError, string message, RequestState pnRequestState, PNStatusCategory pnStatusCategory)
{
return(Helpers.CreatePNStatus(
pnStatusCategory,
message,
(isError)?new PubNubException(message):null,
isError,
OperationType,
ChannelsToUse,
ChannelGroupsToUse,
pnRequestState,
PubNubInstance
));
}
protected PNStatus CreateErrorResponseFromMessage(string message, RequestState pnRequestState, PNStatusCategory pnStatusCategory)
{
return(Helpers.CreatePNStatus(
pnStatusCategory,
message,
new PubNubException(message),
true,
OperationType,
ChannelsToUse,
ChannelGroupsToUse,
pnRequestState,
PubNubInstance
));
}
public PNStatus CreateStatusResponse <T>(PNOperationType type, PNStatusCategory category, RequestState <T> asyncRequestState, int statusCode, Exception throwable)
{
PNStatus status = new PNStatus(asyncRequestState != null ? asyncRequestState.EndPointOperation : null);
status.Category = category;
status.Operation = type;
if ((asyncRequestState != null && !asyncRequestState.GotJsonResponse) || throwable != null)
{
status.Error = true;
}
if (throwable != null)
{
if (throwable.InnerException != null)
{
PNErrorData errorData = new PNErrorData(throwable.InnerException.Message, throwable);
status.ErrorData = errorData;
}
else
{
PNErrorData errorData = new PNErrorData(throwable.Message, throwable);
status.ErrorData = errorData;
}
}
if (asyncRequestState != null)
{
if (asyncRequestState.Request != null)
{
status.ClientRequest = asyncRequestState.Request;
HttpValueCollection restUriQueryCollection = HttpUtility.ParseQueryString(asyncRequestState.Request.RequestUri.Query);
if (restUriQueryCollection.ContainsKey("auth"))
{
string auth = restUriQueryCollection["auth"];
status.AuthKey = auth;
}
if (restUriQueryCollection.ContainsKey("uuid"))
{
string uuid = restUriQueryCollection["uuid"];
status.Uuid = uuid;
}
}
if (asyncRequestState.Response != null)
{
status.StatusCode = (int)asyncRequestState.Response.StatusCode;
}
else
{
status.StatusCode = statusCode;
}
if (asyncRequestState.ChannelGroups != null)
{
status.AffectedChannelGroups = asyncRequestState.ChannelGroups.ToList <string>();
}
if (asyncRequestState.Channels != null)
{
status.AffectedChannels = asyncRequestState.Channels.ToList <string>();
}
}
else
{
status.StatusCode = statusCode;
}
status.Origin = config.Origin;
status.TlsEnabled = config.Secure;
return(status);
}
public PNStatus CreateStatusResponse <T>(PNOperationType type, PNStatusCategory category, RequestState <T> asyncRequestState, int statusCode, PNException throwable)
{
int serverErrorStatusCode = 0;
bool serverErrorMessage = false;
List <string> serverAffectedChannels = null;
List <string> serverAffectedChannelGroups = null;
PNStatus status = new PNStatus(asyncRequestState != null ? asyncRequestState.EndPointOperation : null);
status.Category = category;
status.Operation = type;
if ((asyncRequestState != null && !asyncRequestState.GotJsonResponse) || throwable != null)
{
status.Error = true;
}
Exception targetException = null;
if (throwable != null)
{
if (throwable.DirectException)
{
targetException = throwable.InnerException;
}
else
{
targetException = throwable as Exception;
}
}
if (targetException != null)
{
if (targetException.InnerException != null)
{
PNErrorData errorData = new PNErrorData(jsonLibrary.SerializeToJsonString(targetException.InnerException.Message), targetException);
status.ErrorData = errorData;
}
else
{
Dictionary <string, object> deserializeStatus = jsonLibrary.DeserializeToDictionaryOfObject(targetException.Message);
if (deserializeStatus != null && deserializeStatus.Count >= 1 &&
deserializeStatus.ContainsKey("error") && string.Equals(deserializeStatus["error"].ToString(), "true", StringComparison.CurrentCultureIgnoreCase) &&
deserializeStatus.ContainsKey("status") && Int32.TryParse(deserializeStatus["status"].ToString(), out serverErrorStatusCode))
{
serverErrorMessage = true;
if (deserializeStatus.ContainsKey("payload"))
{
Dictionary <string, object> payloadDic = jsonLibrary.ConvertToDictionaryObject(deserializeStatus["payload"]);
if (payloadDic != null && payloadDic.Count > 0)
{
if (payloadDic.ContainsKey("channels"))
{
object[] chDic = jsonLibrary.ConvertToObjectArray(payloadDic["channels"]);
if (chDic != null && chDic.Length > 0)
{
serverAffectedChannels = chDic.Select(x => x.ToString()).ToList();
}
}
if (payloadDic.ContainsKey("channel-groups"))
{
object[] cgDic = jsonLibrary.ConvertToObjectArray(payloadDic["channel-groups"]);
if (cgDic != null && cgDic.Length > 0)
{
serverAffectedChannelGroups = cgDic.Select(x => x.ToString()).ToList();
}
}
}
}
}
PNErrorData errorData = new PNErrorData(jsonLibrary.SerializeToJsonString(targetException.Message), targetException);
status.ErrorData = errorData;
}
}
if (asyncRequestState != null)
{
if (asyncRequestState.Request != null)
{
status.ClientRequest = asyncRequestState.Request;
HttpValueCollection restUriQueryCollection = HttpUtility.ParseQueryString(asyncRequestState.Request.RequestUri.Query);
if (restUriQueryCollection.ContainsKey("auth"))
{
string auth = restUriQueryCollection["auth"];
status.AuthKey = auth;
}
if (restUriQueryCollection.ContainsKey("uuid"))
{
string uuid = restUriQueryCollection["uuid"];
status.Uuid = uuid;
}
}
if (serverErrorMessage && serverErrorStatusCode > 0)
{
status.StatusCode = serverErrorStatusCode;
}
else if (asyncRequestState.Response != null)
{
status.StatusCode = (int)asyncRequestState.Response.StatusCode;
}
else
{
status.StatusCode = statusCode;
}
if (serverErrorMessage)
{
status.AffectedChannels = serverAffectedChannels;
status.AffectedChannelGroups = serverAffectedChannelGroups;
}
else
{
if (asyncRequestState.ChannelGroups != null)
{
status.AffectedChannelGroups = asyncRequestState.ChannelGroups.ToList <string>();
}
if (asyncRequestState.Channels != null)
{
status.AffectedChannels = asyncRequestState.Channels.ToList <string>();
}
}
}
else
{
status.StatusCode = statusCode;
}
if (status.StatusCode == 403)
{
status.Category = PNStatusCategory.PNAccessDeniedCategory;
}
status.Origin = config.Origin;
status.TlsEnabled = config.Secure;
return(status);
}
public static bool TryCheckErrorTypeAndCallback <T> (CustomEventArgs cea, PubNubUnity pnUnity, out PNStatus pnStatus)
{
bool retBool = false;
PNStatusCategory pnStatusCat = PNStatusCategory.PNUnknownCategory;
if (cea.IsTimeout || CheckRequestTimeoutMessageInError(cea))
{
pnStatusCat = PNStatusCategory.PNTimeoutCategory;
retBool = true;
}
else if (cea.IsError)
{
if ((cea.Message.Contains("NameResolutionFailure") ||
cea.Message.Contains("ConnectFailure") ||
cea.Message.Contains("ServerProtocolViolation") ||
cea.Message.Contains("ProtocolError")
))
{
pnStatusCat = PNStatusCategory.PNNetworkIssuesCategory;
}
else if (cea.Message.Contains("Aborted"))
{
pnStatusCat = PNStatusCategory.PNCancelledCategory;
}
else if ((cea.Message.Contains("403")) ||
(cea.Message.Contains("java.io.FileNotFoundException")) ||
((pnUnity.Version.Contains("UnityWeb")) && (cea.Message.Contains("Failed downloading"))))
{
pnStatusCat = PNStatusCategory.PNAccessDeniedCategory;
}
else if (cea.PubNubRequestState != null)
{
switch (cea.PubNubRequestState.ResponseCode)
{
case 403:
pnStatusCat = PNStatusCategory.PNAccessDeniedCategory;
break;
case 500:
case 502:
case 503:
case 481:
case 451:
pnStatusCat = PNStatusCategory.PNUnexpectedDisconnectCategory;
break;
case 504:
pnStatusCat = PNStatusCategory.PNTimeoutCategory;
break;
case 414:
case 400:
pnStatusCat = PNStatusCategory.PNBadRequestCategory;
break;
default:
pnStatusCat = PNStatusCategory.PNUnknownCategory;
break;
}
}
retBool = true;
}
else
{
retBool = false;
}
if (retBool)
{
pnStatus = CreatePNStatus(
pnStatusCat,
cea.Message,
null,
retBool,
PNOperationType.PNSubscribeOperation,
pnUnity.SubscriptionInstance.AllChannels,
pnUnity.SubscriptionInstance.AllChannelGroups,
cea.PubNubRequestState,
pnUnity
);
}
else
{
pnStatus = null;
}
return(retBool);
}
private void Publish(string channel, object message, bool storeInHistory, int ttl, 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();
status.Error = true;
status.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();
status.Error = true;
status.ErrorData = new PNErrorData("Invalid publish key", new MissingMemberException("Invalid publish key"));
callback.OnResponse(null, status);
return;
}
if (callback == null)
{
return;
}
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr);
urlBuilder.PubnubInstanceId = (PubnubInstance != null) ? PubnubInstance.InstanceId : "";
Uri request = urlBuilder.BuildPublishRequest(channel, message, storeInHistory, ttl, metaData, httpPost, null, externalQueryParam);
RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>();
requestState.Channels = new [] { channel };
requestState.ResponseType = PNOperationType.PNPublishOperation;
requestState.PubnubCallback = callback;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
string json = "";
if (this.httpPost)
{
requestState.UsePostMethod = true;
string postMessage = JsonEncodePublishMsg(message);
json = UrlProcessRequest <PNPublishResult>(request, requestState, false, postMessage);
}
else
{
json = UrlProcessRequest <PNPublishResult>(request, requestState, false);
}
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)
{
ProcessResponseCallbacks(result, requestState);
}
else
{
PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString());
PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNPublishOperation, category, requestState, 400, new PNException(json));
if (requestState.PubnubCallback != null)
{
requestState.PubnubCallback.OnResponse(default(PNPublishResult), status);
}
}
}
else
{
ProcessResponseCallbacks(result, requestState);
}
}
CleanUp();
}
public void Initialize(bool isError, PNStatusCategory category, Exception exception = null)
{
BaseInitialize(isError, exception);
Category = category;
}
protected PNStatus CreateErrorResponseFromException(Exception ex, RequestState pnRequestState, PNStatusCategory pnStatusCategory)
{
return(Helpers.CreatePNStatus(
pnStatusCategory,
ex.Message,
ex,
true,
OperationType,
ChannelsToUse,
ChannelGroupsToUse,
pnRequestState,
PubNubInstance
));
}
