internal Uri AppendTokenToURL(string request, string resourceID, PNResourceType resourceType, PNOperationType type)
{
string token = GetToken(resourceID, resourceType);
StringBuilder uriBuilder = new StringBuilder(request);
if (!string.IsNullOrEmpty(token))
{
uriBuilder.AppendFormat("&auth={0}", Utility.EncodeUricomponent(token, type, false, false));
}
else
{
if (!string.IsNullOrEmpty(this.PubNubInstance.PNConfig.AuthKey))
{
uriBuilder.AppendFormat("&auth={0}", Utility.EncodeUricomponent(this.PubNubInstance.PNConfig.AuthKey, type, false, false));
}
}
return(new Uri(uriBuilder.ToString()));
}
public GrantResourcesWithPermissions GetTokensByResource(PNResourceType resourceType)
{
GrantResourcesWithPermissions grantResourcesWithPermissions = InitGrantResourcesWithPermissions();
switch (resourceType)
{
case PNResourceType.PNChannels:
grantResourcesWithPermissions.Channels = Tokens.Channels;
grantResourcesWithPermissions.ChannelsPattern = Tokens.ChannelsPattern;
break;
case PNResourceType.PNGroups:
grantResourcesWithPermissions.Groups = Tokens.Groups;
grantResourcesWithPermissions.GroupsPattern = Tokens.GroupsPattern;
break;
case PNResourceType.PNSpaces:
grantResourcesWithPermissions.Spaces = Tokens.Spaces;
grantResourcesWithPermissions.SpacesPattern = Tokens.SpacesPattern;
break;
case PNResourceType.PNUsers:
grantResourcesWithPermissions.Users = Tokens.Users;
grantResourcesWithPermissions.UsersPattern = Tokens.UsersPattern;
break;
default:
#if (ENABLE_PUBNUB_LOGGING)
this.PubNubInstance.PNLog.WriteToLog(string.Format("No match on GetTokensByResource: {0}", resourceType), PNLoggingMethod.LevelInfo);
#endif
break;
}
return(grantResourcesWithPermissions);
}
public string GetToken(string resourceID, PNResourceType resourceType)
{
PubNubUnityInitializationAfterCleanup();
return(pnUnity.TokenMgr.GetToken(resourceID, resourceType));
}
public GrantResourcesWithPermissions GetTokensByResource(PNResourceType resourceType)
{
PubNubUnityInitializationAfterCleanup();
return(pnUnity.TokenMgr.GetTokensByResource(resourceType));
}
public void FillGrantResourcesWithPermissions(Dictionary <string, int> resDict, string token, long timetoken, int ttl, bool isPattern, PNResourceType pnResourceType)
{
if ((resDict != null) && (resDict.Count > 0))
{
foreach (KeyValuePair <string, int> kvp in resDict)
{
#if (ENABLE_PUBNUB_LOGGING)
this.PubNubInstance.PNLog.WriteToLog(string.Format("FillGrantResourcesWithPermissions ==> {0}", kvp.Key), PNLoggingMethod.LevelInfo);
#endif
switch (pnResourceType)
{
case PNResourceType.PNChannels:
ChannelPermissionsWithToken channelPermissionsWithToken = new ChannelPermissionsWithToken {
BitMaskPerms = kvp.Value,
Token = token,
Timestamp = timetoken,
TTL = ttl,
Permissions = ParseGrantPrems(kvp.Value, pnResourceType) as ChannelPermissions,
};
if (isPattern)
{
Tokens.ChannelsPattern[kvp.Key] = channelPermissionsWithToken;
}
else
{
Tokens.Channels[kvp.Key] = channelPermissionsWithToken;
}
break;
case PNResourceType.PNGroups:
GroupPermissionsWithToken groupPermissionsWithToken = new GroupPermissionsWithToken {
BitMaskPerms = kvp.Value,
Token = token,
Timestamp = timetoken,
TTL = ttl,
Permissions = ParseGrantPrems(kvp.Value, pnResourceType) as GroupPermissions,
};
if (isPattern)
{
Tokens.GroupsPattern[kvp.Key] = groupPermissionsWithToken;
}
else
{
Tokens.Groups[kvp.Key] = groupPermissionsWithToken;
}
break;
case PNResourceType.PNSpaces:
UserSpacePermissionsWithToken spacePermissionsWithToken = new UserSpacePermissionsWithToken {
BitMaskPerms = kvp.Value,
Token = token,
Timestamp = timetoken,
TTL = ttl,
Permissions = ParseGrantPrems(kvp.Value, pnResourceType) as UserSpacePermissions,
};
if (isPattern)
{
Tokens.SpacesPattern[kvp.Key] = spacePermissionsWithToken;
}
else
{
Tokens.Spaces[kvp.Key] = spacePermissionsWithToken;
}
break;
case PNResourceType.PNUsers:
UserSpacePermissionsWithToken userPermissionsWithToken = new UserSpacePermissionsWithToken {
BitMaskPerms = kvp.Value,
Token = token,
Timestamp = timetoken,
TTL = ttl,
Permissions = ParseGrantPrems(kvp.Value, pnResourceType) as UserSpacePermissions,
};
if (isPattern)
{
Tokens.UsersPattern[kvp.Key] = userPermissionsWithToken;
}
else
{
Tokens.Users[kvp.Key] = userPermissionsWithToken;
}
break;
default:
#if (ENABLE_PUBNUB_LOGGING)
this.PubNubInstance.PNLog.WriteToLog(string.Format("No match on FillGrantResourcesWithPermissions: {0}", pnResourceType), PNLoggingMethod.LevelInfo);
#endif
break;
}
}
}
}
public ResourcePermission ParseGrantPrems(int b, PNResourceType pnResourceType)
{
UserSpacePermissions rp = new UserSpacePermissions {
Read = false,
Write = false,
Manage = false,
Delete = false,
Create = false,
};
string bits = Convert.ToString(b, 2);
#if (ENABLE_PUBNUB_LOGGING)
this.PubNubInstance.PNLog.WriteToLog("binary==>" + bits, PNLoggingMethod.LevelInfo);
#endif
for (int i = 0; i < bits.Length; i++)
{
#if (ENABLE_PUBNUB_LOGGING)
this.PubNubInstance.PNLog.WriteToLog(string.Format("{0}-{1}", i, bits[i]), PNLoggingMethod.LevelInfo);
#endif
switch (i)
{
case 0:
rp.Read = (bits[i] == '1');
break;
case 1:
rp.Write = (bits[i] == '1');
break;
case 2:
rp.Manage = (bits[i] == '1');
break;
case 3:
rp.Delete = (bits[i] == '1');
break;
case 4:
rp.Create = (bits[i] == '1');
break;
default:
#if (ENABLE_PUBNUB_LOGGING)
this.PubNubInstance.PNLog.WriteToLog(string.Format("No match on ParseGrantPrems: {0}", i), PNLoggingMethod.LevelInfo);
#endif
break;
}
}
#if (ENABLE_PUBNUB_LOGGING)
StringBuilder sbLog = new StringBuilder();
sbLog.AppendFormat("ResourcePermissions Read ==> {0}", rp.Read);
sbLog.AppendFormat("ResourcePermissions Write ==> {0}", rp.Write);
sbLog.AppendFormat("ResourcePermissions Manage ==> {0}", rp.Manage);
sbLog.AppendFormat("ResourcePermissions Delete ==> {0}", rp.Delete);
sbLog.AppendFormat("ResourcePermissions Create ==> {0}", rp.Create);
this.PubNubInstance.PNLog.WriteToLog(sbLog.ToString(), PNLoggingMethod.LevelInfo);
#endif
return(rp);
}
// GetToken first match for direct ids, if no match found use the first token from pattern match ignoring the regex (by design).
public string GetToken(string resourceID, PNResourceType resourceType)
{
switch (resourceType)
{
case PNResourceType.PNChannels:
ChannelPermissionsWithToken channelPermissionsWithToken;
if (Tokens.Channels.TryGetValue(resourceID, out channelPermissionsWithToken))
{
return(channelPermissionsWithToken.Token);
}
if ((Tokens.ChannelsPattern != null) && (Tokens.ChannelsPattern.Count > 0))
{
return(Tokens.ChannelsPattern.First().Value.Token);
}
return("");
case PNResourceType.PNGroups:
GroupPermissionsWithToken groupPermissionsWithToken;
if (Tokens.Groups.TryGetValue(resourceID, out groupPermissionsWithToken))
{
return(groupPermissionsWithToken.Token);
}
if ((Tokens.GroupsPattern != null) && (Tokens.GroupsPattern.Count > 0))
{
return(Tokens.GroupsPattern.First().Value.Token);
}
return("");
case PNResourceType.PNSpaces:
UserSpacePermissionsWithToken spacePermissionsWithToken;
if (Tokens.Spaces.TryGetValue(resourceID, out spacePermissionsWithToken))
{
return(spacePermissionsWithToken.Token);
}
if ((Tokens.SpacesPattern != null) && (Tokens.SpacesPattern.Count > 0))
{
return(Tokens.SpacesPattern.First().Value.Token);
}
return("");
case PNResourceType.PNUsers:
UserSpacePermissionsWithToken userPermissionsWithToken;
if (Tokens.Users.TryGetValue(resourceID, out userPermissionsWithToken))
{
return(userPermissionsWithToken.Token);
}
if ((Tokens.UsersPattern != null) && (Tokens.UsersPattern.Count > 0))
{
return(Tokens.UsersPattern.First().Value.Token);
}
return("");
default:
#if (ENABLE_PUBNUB_LOGGING)
this.PubNubInstance.PNLog.WriteToLog(string.Format("No match on GetToken: {0}", resourceType), PNLoggingMethod.LevelInfo);
#endif
break;
}
return("");
}
