private void ThrowIfNoPermission(DeezerPermissions aPermission)
{
if (!iClient.HasPermission(aPermission))
{
throw new DeezerPermissionsException(aPermission);
}
}
// POST
public Task <bool> Post(string resource,
DeezerPermissions requiredPermissions,
CancellationToken cancellationToken)
=> Post <bool>(resource,
requiredPermissions,
cancellationToken,
ParseBoolOrError);
public DeezerPermissionsException(DeezerPermissions permission)
{
bool hasFormattedText = Permissions.PERMISSION_NAME_LOOKUP.ContainsKey(permission);
this.Message = hasFormattedText ? string.Format(EXCEPTION_MESSAGE_FORMAT, Permissions.PERMISSION_NAME_LOOKUP[permission])
: UNKNOWN_EXCEPTION_MESSAGE;
}
// GET
public Task <TItem> Get <TItem>(string resource, DeezerPermissions requiredPermissions, CancellationToken cancellationToken, Func <JToken, TItem> itemFactory)
{
AssertAuthenticated(requiredPermissions);
string actualResource = AppendAccessTokenToResourceIfRequired(resource);
return(Get <TItem>(actualResource, cancellationToken, itemFactory));
}
//Wrapper around permissions, matching to DeezerPermissions Enum
internal bool HasPermission(DeezerPermissions aPermission)
{
if (IsAuthenticated && iPermissions != null)
{
return(iPermissions.HasPermission(aPermission));
}
return(false);
}
public void ExceptionMessageForKnownPermission(DeezerPermissions permission, string permissionAsString)
{
var expectedMessage = string.Format(DeezerPermissionsException.EXCEPTION_MESSAGE_FORMAT, permissionAsString);
var actual = new DeezerPermissionsException(permission);
Assert.AreEqual(expectedMessage, actual.Message);
}
//Performs a DELETE request
public Task <bool> Delete(string method, IList <IRequestParameter> parms, DeezerPermissions aRequiredPermission)
{
CheckAuthentication();
CheckPermissions(aRequiredPermission);
AddDefaultsToParamList(parms);
return(this.executor.ExecuteDelete(method, parms));
}
public bool HasPermission(DeezerPermissions aRequiredPermissions)
{
if (IsAuthenticated && iPermissions != null)
{
return(iPermissions.HasPermission(aRequiredPermissions));
}
return(false);
}
public Task <T> Post <T>(string method, IList <IRequestParameter> parms, DeezerPermissions requiredPermissions)
{
CheckAuthentication();
CheckPermissions(requiredPermissions);
AddDefaultsToParamList(parms);
return(this.executor.ExecutePost <T>(method, parms));
}
//Performs a DELETE request
public Task <bool> Delete(string aMethod, IList <IRequestParameter> aParams, DeezerPermissions aRequiredPermission)
{
CheckAuthentication();
CheckPermissions(aRequiredPermission);
AddDefaultsToParamList(aParams);
return(iExecutor.ExecuteDelete(aMethod, aParams)
.ContinueWith((aTask) => aTask.Result.IsSuccessStatusCode, CancellationToken, TaskContinuationOptions.NotOnCanceled, TaskScheduler.Default));
}
public OAuthClient(string appId,
string appSecret,
string redirectUri,
DeezerPermissions requestedPermissions)
{
this.appId = appId;
this.appSecret = appSecret;
this.redirectUri = redirectUri;
this.LoginUri = GenerateLoginUri(requestedPermissions);
}
public Task <TResult> Post <TResult>(string resource,
DeezerPermissions requiredPermissions,
CancellationToken cancellationToken,
Func <JToken, TResult> resultFactory)
=> Post <TResult>(resource,
requiredPermissions,
cancellationToken,
stream =>
{
var json = JObjectFromStream(stream);
return(DeserializeErrorOr <TResult>(json, resultFactory));
});
private void CheckPermissions(DeezerPermissions aRequiredPermissions)
{
if (iPermissions == null)
{
throw new NotLoggedInException();
}
if (!HasPermission(aRequiredPermissions))
{
throw new DeezerPermissionsException(aRequiredPermissions);
}
}
public DeezerPermissionsException(DeezerPermissions aPermission)
{
switch (aPermission)
{
case DeezerPermissions.BasicAccess: { iMessage = BASIC; break; }
case DeezerPermissions.ListeningHistory: { iMessage = HISTORY; break; }
case DeezerPermissions.Email: { iMessage = EMAIL; break; }
case DeezerPermissions.OfflineAccess: { iMessage = OFFLINE; break; }
case DeezerPermissions.ManageCommunity: { iMessage = COMMUNITY; break; }
case DeezerPermissions.DeleteLibrary: { iMessage = DELETE; break; }
default: { iMessage = UNKNOWN; break; }
}
}
public bool HasPermission(DeezerPermissions aPermission)
{
switch (aPermission)
{
case DeezerPermissions.BasicAccess: { return HasBasicAccess; }
case DeezerPermissions.DeleteLibrary: { return HasDeleteLibrary; }
case DeezerPermissions.Email: { return HasEmail; }
case DeezerPermissions.ListeningHistory: { return HasListeningHistory; }
case DeezerPermissions.ManageCommunity: { return HasManageCommunity; }
case DeezerPermissions.ManageLibrary: { return HasManageLibrary; }
case DeezerPermissions.OfflineAccess: { return HasOfflineAccess; }
default: { return false; }
}
}
//Performs a POST request
internal Task <bool> Post(string aMethod, IList <IRequestParameter> aParams, DeezerPermissions aRequiredPermission)
{
if (!IsAuthenticated)
{
throw new NotLoggedInException();
}
if (!HasPermission(aRequiredPermission))
{
throw new DeezerPermissionsException(aRequiredPermission);
}
AddDefaultsToParamList(aParams);
return(iExecutor.ExecutePost <bool>(aMethod, aParams).ContinueWith <bool>((aTask) => aTask.Result.Data, CancellationToken, TaskContinuationOptions.NotOnCanceled, TaskScheduler.Default));
}
public Task <T> Post <T>(string aMethod, IList <IRequestParameter> aParams, DeezerPermissions aRequiredPermission)
{
CheckAuthentication();
CheckPermissions(aRequiredPermission);
AddDefaultsToParamList(aParams);
return(iExecutor.ExecutePost(aMethod, aParams)
.ContinueWith <T>((aTask) =>
{
CheckHttpResponse(aTask);
T deserialized = DeserializeResponse <T>(aTask.Result.Content).Result;
return deserialized;
}, CancellationToken, TaskContinuationOptions.NotOnCanceled, TaskScheduler.Default));
}
private Task <TResult> Delete <TResult>(string resource,
DeezerPermissions requiredPermissions,
CancellationToken cancellationToken,
Func <Stream, TResult> resultFactory)
{
AssertAuthenticated(requiredPermissions);
string actualResource = AppendAccessTokenToResourceIfRequired(resource);
return(executor.ExecuteDelete(actualResource, cancellationToken)
.ContinueWith(t =>
{
t.ThrowIfFaulted();
return resultFactory(t.Result);
}, cancellationToken, TaskContinuationOptions.NotOnCanceled | TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default));
}
//Internal wrapper around get for all user methods :)
private Task <IEnumerable <TDest> > Get <TSource, TDest>(string aMethod, DeezerPermissions aPermisisons, uint aStart, uint aCount) where TSource : TDest, IDeserializable <DeezerClient>
{
if (!Client.IsAuthenticated)
{
throw new NotLoggedInException();
}
if (!Client.HasPermission(aPermisisons))
{
throw new DeezerPermissionsException(aPermisisons);
}
string method = string.Format("user/me/{0}", aMethod);
return(Client.Get <TSource>(method, aStart, aCount).ContinueWith <IEnumerable <TDest> >((aTask) =>
{
return Client.Transform <TSource, TDest>(aTask.Result);
}, Client.CancellationToken, TaskContinuationOptions.NotOnCanceled, TaskScheduler.Default));
}
public DeezerPermissionsException(DeezerPermissions aPermission)
{
switch (aPermission)
{
case DeezerPermissions.BasicAccess: { iMessage = BASIC; break; }
case DeezerPermissions.ListeningHistory: { iMessage = HISTORY; break; }
case DeezerPermissions.Email: { iMessage = EMAIL; break; }
case DeezerPermissions.OfflineAccess: { iMessage = OFFLINE; break; }
case DeezerPermissions.ManageCommunity: { iMessage = COMMUNITY; break; }
case DeezerPermissions.DeleteLibrary: { iMessage = DELETE; break; }
default: { iMessage = UNKNOWN; break; }
}
}
//TODO - Check a method that has multiple permissions...
public bool HasPermission(DeezerPermissions aPermission)
{
bool permission = true;
if (aPermission.HasPermission(DeezerPermissions.BasicAccess))
{
permission &= HasBasicAccess;
}
if (aPermission.HasPermission(DeezerPermissions.DeleteLibrary))
{
permission &= HasDeleteLibrary;
}
if (aPermission.HasPermission(DeezerPermissions.Email))
{
permission &= HasEmail;
}
if (aPermission.HasPermission(DeezerPermissions.ListeningHistory))
{
permission &= HasListeningHistory;
}
if (aPermission.HasPermission(DeezerPermissions.ManageCommunity))
{
permission &= HasManageCommunity;
}
if (aPermission.HasPermission(DeezerPermissions.ManageLibrary))
{
permission &= HasManageLibrary;
}
if (aPermission.HasPermission(DeezerPermissions.OfflineAccess))
{
permission &= HasOfflineAccess;
}
return(permission);
}
public static string PermissionToString(this DeezerPermissions permissions)
{
List <string> perms = new List <string>(8);
if (permissions.HasPermission(DeezerPermissions.BasicAccess))
{
perms.Add(BASIC_ACCESS);
}
if (permissions.HasPermission(DeezerPermissions.Email))
{
perms.Add(EMAIL);
}
if (permissions.HasPermission(DeezerPermissions.DeleteLibrary))
{
perms.Add(DELETE_LIBRARY);
}
if (permissions.HasPermission(DeezerPermissions.ListeningHistory))
{
perms.Add(LISTENING_HISTORY);
}
if (permissions.HasPermission(DeezerPermissions.ManageCommunity))
{
perms.Add(MANAGE_COMMUNITY);
}
if (permissions.HasPermission(DeezerPermissions.ManageLibrary))
{
perms.Add(MANAGE_LIBRARY);
}
if (permissions.HasPermission(DeezerPermissions.OfflineAccess))
{
perms.Add(OFFLINE_ACCESS);
}
return(string.Join(", ", perms));
}
public static string PermissionToString(this DeezerPermissions aPermission)
{
List <string> perms = new List <string>(10);
if (aPermission.HasFlag(DeezerPermissions.BasicAccess))
{
perms.Add(dBasicAccess);
}
if (aPermission.HasFlag(DeezerPermissions.DeleteLibrary))
{
perms.Add(dDeleteLibrary);
}
if (aPermission.HasFlag(DeezerPermissions.Email))
{
perms.Add(dEmail);
}
if (aPermission.HasFlag(DeezerPermissions.ListeningHistory))
{
perms.Add(dListeningHistory);
}
if (aPermission.HasFlag(DeezerPermissions.ManageCommunity))
{
perms.Add(dManageCommunity);
}
if (aPermission.HasFlag(DeezerPermissions.ManageLibrary))
{
perms.Add(dManageLibrary);
}
if (aPermission.HasFlag(DeezerPermissions.OfflineAccess))
{
perms.Add(dOffliceAccess);
}
return(string.Join(", ", perms));
}
//Generates a permission string which can be used to grant people
//Access to features of the app
public static string GeneratePermissionString(DeezerPermissions iPermissions)
{
string perms = null;
if ((iPermissions & DeezerPermissions.BasicAccess) == DeezerPermissions.BasicAccess)
{
AddToString(perms, DeezerPermissions.BasicAccess.PermissionToString());
}
if ((iPermissions & DeezerPermissions.DeleteLibrary) == DeezerPermissions.DeleteLibrary)
{
AddToString(perms, DeezerPermissions.DeleteLibrary.PermissionToString());
}
if ((iPermissions & DeezerPermissions.Email) == DeezerPermissions.Email)
{
AddToString(perms, DeezerPermissions.Email.PermissionToString());
}
if ((iPermissions & DeezerPermissions.ListeningHistory) == DeezerPermissions.ListeningHistory)
{
AddToString(perms, DeezerPermissions.ListeningHistory.PermissionToString());
}
if ((iPermissions & DeezerPermissions.ManageCommunity) == DeezerPermissions.ManageCommunity)
{
AddToString(perms, DeezerPermissions.ManageCommunity.PermissionToString());
}
if ((iPermissions & DeezerPermissions.ManageLibrary) == DeezerPermissions.ManageLibrary)
{
AddToString(perms, DeezerPermissions.ManageLibrary.PermissionToString());
}
if ((iPermissions & DeezerPermissions.OfflineAccess) == DeezerPermissions.OfflineAccess)
{
AddToString(perms, DeezerPermissions.OfflineAccess.PermissionToString());
}
return(perms);
}
public static string PermissionToString(this DeezerPermissions aPermission)
{
switch (aPermission)
{
case DeezerPermissions.BasicAccess: { return("basic_access"); }
case DeezerPermissions.Email: { return("email"); }
case DeezerPermissions.OfflineAccess: { return("offline_access"); }
case DeezerPermissions.ManageLibrary: { return("manage_library"); }
case DeezerPermissions.ManageCommunity: { return("manage_community"); }
case DeezerPermissions.DeleteLibrary: { return("delete_history"); }
case DeezerPermissions.ListeningHistory: { return("listening_history"); }
default: { return(string.Empty); }
}
}
public bool HasPermission(DeezerPermissions aPermission)
{
switch (aPermission)
{
case DeezerPermissions.BasicAccess: { return(HasBasicAccess); }
case DeezerPermissions.DeleteLibrary: { return(HasDeleteLibrary); }
case DeezerPermissions.Email: { return(HasEmail); }
case DeezerPermissions.ListeningHistory: { return(HasListeningHistory); }
case DeezerPermissions.ManageCommunity: { return(HasManageCommunity); }
case DeezerPermissions.ManageLibrary: { return(HasManageLibrary); }
case DeezerPermissions.OfflineAccess: { return(HasOfflineAccess); }
default: { return(false); }
}
}
private string GenerateLoginUri(DeezerPermissions requestedPermissions)
{
StringBuilder sb = new StringBuilder(1024);
sb.Append(BASE_OAUTH_URI);
sb.Append('/');
sb.Append(LOGIN_ENDPOINT);
sb.Append('?');
sb.Append(Constants.APPID_QUERY_KEY);
sb.Append('=');
sb.Append(Uri.EscapeUriString(this.appId));
sb.Append('&');
sb.Append(Constants.REDIRECTURI_QUERY_KEY);
sb.Append('=');
sb.Append(Uri.EscapeUriString(this.redirectUri));
sb.Append('&');
sb.Append(Constants.PERMS_QUERY_KEY);
sb.Append('=');
sb.Append(Uri.EscapeUriString(requestedPermissions.PermissionToString()));
return(sb.ToString());
}
public void PermissionToString(DeezerPermissions input, string expected)
{
Assert.AreEqual(expected, input.PermissionToString());
}
public void TestHasPermissions(DeezerPermissions permissions, DeezerPermissions requestedPermission, bool shouldBeAvailable)
{
Assert.AreEqual(shouldBeAvailable, permissions.HasPermission(requestedPermission));
}
public static bool HasPermission(this DeezerPermissions permissions, DeezerPermissions expectedPermission) => (permissions & expectedPermission) > 0;
private void ThrowIfNoPermission(DeezerPermissions aPermission)
{
if (!iClient.HasPermission(aPermission)) { throw new DeezerPermissionsException(aPermission); }
}
// IAuthenticationServiceInternal public bool HasPermission(DeezerPermissions requestedPermission) => this.UserPermissions != null && this.UserPermissions.HasPermission(requestedPermission);
