/// <inheritdoc/>
public async Task SendPlayQueueToPlayer(string plexServerHost, string authToken, string hostIdentifier, PlayQueueContainer playQueue, string type, string playerIdentifier, string transientToken, long offset)
{
var uri = new Uri(plexServerHost);
var queryParams =
new Dictionary <string, string>
{
{ "providerIdentifier", "com.plexapp.plugins.library" },
{ "protocol", uri.Scheme },
{ "address", uri.DnsSafeHost },
{ "port", uri.Port.ToString() },
{ "containerKey", "/playQueues/" + playQueue.PlayQueueId + "?own=1" },
{ "key", "/library/metadata/" + playQueue.PlayQueueSelectedMetadataItemId },
{ "offset", offset.ToString() },
{ "commandID", "1" },
{ "type", type },
{ "machineIdentifier", hostIdentifier },
{ "token", transientToken }
};
var apiRequest =
new ApiRequestBuilder(plexServerHost, $"player/playback/playMedia", HttpMethod.Get)
.AddPlexToken(authToken)
.AddQueryParams(queryParams)
.AddHeader("X-Plex-Target-Client-Identifier", playerIdentifier)
.AddRequestHeaders(ClientUtilities.GetClientIdentifierHeader(this.clientOptions.ClientId))
.AcceptJson()
.Build();
await this.apiService.InvokeApiAsync(apiRequest);
}
/// <inheritdoc/>
public async Task <CollectionContainer> GetCollectionsAsync(string authToken, string plexServerHost,
string libraryKey, string title)
{
var queryParams =
new Dictionary <string, string> {
{ "includeCollections", "1" }, { "includeExternalMedia", "true" }
};
if (!string.IsNullOrEmpty(title))
{
queryParams.Add("title" + "%3d", title);
}
var apiRequest = new ApiRequestBuilder(plexServerHost, $"library/sections/{libraryKey}/collections",
HttpMethod.Get)
.AddQueryParams(queryParams)
.AddPlexToken(authToken)
.AddRequestHeaders(ClientUtilities.GetClientIdentifierHeader(this.clientOptions.ClientId))
.AcceptJson()
.Build();
var wrapper = await this.apiService.InvokeApiAsync <GenericWrapper <CollectionContainer> >(apiRequest);
return(wrapper.Container);
}
/// <inheritdoc/>
public async Task <PlayQueueContainer> CreatePlayQueue(string authToken, string plexServerHost, string hostIdentifier, string type,
string key, bool isRepeat, bool isShuffle, bool isContinous)
{
var uri = "server://" + hostIdentifier + "/com.plexapp.plugins.library/library/metadata/" + key;
var queryParams =
new Dictionary <string, string>
{
{ "continuous", isContinous ? "1" : "0" },
{ "uri", uri },
{ "type", type },
{ "repeat", isRepeat ? "1" : "0" },
{ "shuffle", isShuffle ? "1" : "0" },
{ "own", "1" },
{ "includeChapters", "1" },
{ "includeMarkers", "1" },
{ "includeGeolocation", "1" },
{ "includeExternalMedia", "1" },
};
var apiRequest =
new ApiRequestBuilder(plexServerHost, $"playQueues", HttpMethod.Post)
.AddPlexToken(authToken)
.AddQueryParams(queryParams)
.AddRequestHeaders(ClientUtilities.GetClientIdentifierHeader(this.clientOptions.ClientId))
.AcceptJson()
.Build();
var wrapper = await this.apiService.InvokeApiAsync <GenericWrapper <PlayQueueContainer> >(apiRequest);
return(wrapper.Container);
}
public void ReturnEmptyResponseWhenRecommendationServiceFails()
{
//Arrange
WalmartApiConfig urls = ApiTestDataHelper.GetApiConfig();
IApiRequestBuilder requestbuilder = new ApiRequestBuilder();
var mockWalmartApiRequestManager = new Mock <IHttpApiRequestManager>();
var responseDataSample = "{\"errors\":[{\"code\":4022,\"message\":\"No recommendations found for item 36461211\"}]}";
mockWalmartApiRequestManager.Setup(mgr => mgr.GetDataAsync(It.IsAny <String>()))
.Returns(Task.FromResult <string>(responseDataSample));
var mockLogger = new Mock <ILogger <ApiServiceBase> >();
IWalmartApiService productService =
new WalmartApiService(mockWalmartApiRequestManager.Object, requestbuilder, urls, mockLogger.Object);
var itemId = 36461211;
//Act
var result = productService.GetProductRecommendationAsync(itemId).Result;
//Assert
Assert.False(result.HasError);
Assert.Null(result.Response);
mockWalmartApiRequestManager.VerifyAll();
}
public void ReturnRecommendationsForProduct()
{
//Arrange
WalmartApiConfig urls = ApiTestDataHelper.GetApiConfig();
IApiRequestBuilder requestbuilder = new ApiRequestBuilder();
var mockWalmartApiRequestManager = new Mock <IHttpApiRequestManager>();
var responseDataSample = ApiTestDataHelper
.GetApiResponseDataFromResource("Walmart.Api.Client.Tests.ProductRecommendationSampleResponse.json");
mockWalmartApiRequestManager.Setup(mgr => mgr.GetDataAsync(It.IsAny <String>()))
.Returns(Task.FromResult <string>(responseDataSample));
var mockLogger = new Mock <ILogger <ApiServiceBase> >();
IWalmartApiService productService =
new WalmartApiService(mockWalmartApiRequestManager.Object, requestbuilder, urls, mockLogger.Object);
var itemId = 36461211;
//Act
var result = productService.GetProductRecommendationAsync(itemId).Result;
//Assert
Assert.False(result.HasError);
Assert.Equal(11, result.Response.Count);
mockWalmartApiRequestManager.VerifyAll();
}
/// <summary>
/// Update Collection
/// </summary>
/// <returns></returns>
public async Task UpdateCollection(string authToken, string plexServerHost, string libraryKey,
CollectionModel collectionModel)
{
var apiRequest =
new ApiRequestBuilder(plexServerHost, "library/sections/" + libraryKey + "/all", HttpMethod.Put)
.AddPlexToken(authToken)
.AddRequestHeaders(GetClientIdentifierHeader())
.AcceptJson()
.AddQueryParams(new Dictionary <string, string>()
{
{ "type", "18" },
{ "id", collectionModel.RatingKey },
{ "includeExternalMedia", "1" },
{ "title.value", collectionModel.Title },
{ "titleSort.value", collectionModel.TitleSort },
{ "summary.value", collectionModel.Summary },
{ "contentRating.value", collectionModel.ContentRating },
{ "title.locked", "1" },
{ "titleSort.locked", "1" },
{ "contentRating.locked", "1" }
})
.Build();
await _apiService.InvokeApiAsync(apiRequest);
}
public async void execute()
{
var client = new ApiClient.ApiClient("http://127.0.0.1:8000/");
var request = new ApiRequestBuilder();
string token;
var req = request
.buildHttpRequest()
.addParameters("email", "*****@*****.**")
.addParameters("password", "password")
.setEndpoint("api/login/")
.setRequestMethod(HttpMethod.Post);
var response = await client.sendRequest(request.getApiRequestBundle());
token = response.getJObject()["access_token"].ToString();
client.setAuthorizationToken(token);
MyList <MyFile> files = new OpenFile().openFile(false);
MyList <string> fileKey = new MyList <string>()
{
"file"
};
var formContent = new MultipartFormDataContent();
formContent.Add(new StringContent("restapis.png"), "title"); //parameters request, "value","key"
formContent.Add(new StreamContent(new MemoryStream(files[0].byteArray)), fileKey[0], files[0].fullFileName); //file yang diupload
req = new ApiRequestBuilder().buildMultipartRequest(new MultiPartContent(formContent))
.setRequestMethod(HttpMethod.Post)
.setEndpoint("api/store-file");
response = await client.sendRequest(req.getApiRequestBundle());
Console.WriteLine(response.getHttpResponseMessage().ToString());
}
public async void create(
string _name,
string _description,
string _address,
string _contact,
String _latitude,
String _longitude,
String _id,
string _token,
MyFile newImage
)
{
MyList <string> fileKey = new MyList <string>()
{
"image"
};
MyList <MyFile> file = new MyList <MyFile>()
{
newImage
};
this.token = _token;
var client = new ApiClient("http://api.dolankuy.me/api/");
var req = new ApiRequestBuilder()
.buildHttpRequest()
.addParameters("category_id", _id)
.addParameters("name", _name)
.addParameters("address", _address)
.addParameters("description", _description)
.addParameters("contact", _contact)
.addParameters("latitude", _latitude)
.addParameters("longitude", _longitude)
.setRequestMethod(HttpMethod.Post)
.setEndpoint("locations/create");
client.setAuthorizationToken(_token);
if (newImage == null)
{
client.setOnSuccessRequest(setViewRegisterStatus);
}
var response = await client.sendRequest(req.getApiRequestBundle());
if (newImage != null)
{
MultiPartContent multiPartContent1 = new MultiPartContent(file, fileKey);
var req2 = new ApiRequestBuilder()
.buildMultipartRequest(multiPartContent1)
.setRequestMethod(HttpMethod.Post)
.setEndpoint("locations/update/" + response.getJObject()["id"].ToString());
client.setAuthorizationToken(_token);
client.setOnSuccessRequest(setViewRegisterStatus);
var response2 = await client.sendRequest(req2.getApiRequestBundle());
}
}
public async void updateUser(int userId, string name, string email, string currentPassword,
string newPassword, string currentImagePath,
MyFile newImageFile)
{
string newImagePath;
JObject userDataJson = new JObject();
JObject userJson = new JObject();
ApiClient client = ApiUtil.Instance.vClient;
ApiRequestBuilder requestBuilder;
ApiRequestBundle requestBundle;
HttpResponseBundle response = null;
getView().callMethod("startLoading");
if (currentPassword != null && newPassword != null)
{
bool validatePasswordSuccess = await validatePassword(currentPassword);
if (!validatePasswordSuccess)
{
getView().callMethod("endLoading");
return;
}
userDataJson.Add("password", newPassword);
}
newImagePath = await postUserImage(newImageFile);
userDataJson.Add("name", name);
userDataJson.Add("email", email);
userDataJson.Add("role", "owner");
userDataJson.Add("image", newImagePath == null ? currentImagePath : newImagePath);
userJson.Add("user", userDataJson);
requestBuilder = new ApiRequestBuilder()
.buildHttpRequest()
.setRequestMethod(HttpMethod.Put)
.setEndpoint("users/" + userId.ToString())
.addJSON <JObject>(userJson);
requestBundle = requestBuilder.getApiRequestBundle();
client.setAuthorizationToken(StorageUtil.Instance.token);
client.setOnSuccessRequest(onSuccessUpdateUser);
client.setOnFailedRequest(onFailedUpdateUser);
try
{
response = await client.sendRequest(requestBundle);
if (response.getHttpResponseMessage().IsSuccessStatusCode)
{
setUserInLocalStorage(userId);
}
}
catch (Exception e)
{
getView().callMethod("endLoading");
getView().callMethod("showErrorMessage", "Failed updating profile. " + e.Message);
}
}
private async Task <bool> validatePassword(string currentPassword)
{
bool passwordValid = false;
string currentEmail = StorageUtil.Instance.user.email;
ApiClient client = ApiUtil.Instance.vClient;
JObject userDataJson = new JObject();
JObject userJson = new JObject();
ApiRequestBuilder requestBuilder;
ApiRequestBundle requestBundle;
HttpResponseBundle responseBundle = null;
userDataJson.Add("email", currentEmail);
userDataJson.Add("password", currentPassword);
userJson.Add("user", userDataJson);
requestBuilder = new ApiRequestBuilder()
.buildHttpRequest()
.setRequestMethod(HttpMethod.Post)
.addJSON <JObject>(userJson)
.setEndpoint("login");
requestBundle = requestBuilder.getApiRequestBundle();
client.setOnSuccessRequest(null);
client.setOnFailedRequest(null);
try
{
responseBundle = await client.sendRequest(requestBundle);
}
catch (Exception e)
{
getView().callMethod("showErrorMessage",
"Failed to validate current password. " + e.Message);
}
if (responseBundle != null)
{
HttpResponseMessage responseMessage = responseBundle.getHttpResponseMessage();
if (responseMessage.IsSuccessStatusCode)
{
passwordValid = true;
}
else if (responseMessage.StatusCode == HttpStatusCode.Unauthorized)
{
getView().callMethod("showErrorMessage", "Current password is invalid.");
}
else
{
string reasonPhrase = "Reason Phrase: " + responseMessage.ReasonPhrase;
getView().callMethod("showErrorMessage",
"Failed to validate current password. " + reasonPhrase);
}
}
return(passwordValid);
}
public void TestClassWithNoCommandAttr()
{
TestClassWithNoAttr badCommand = new();
Assert.Throws <ArgumentException>(() =>
{
Uri requestUri = ApiRequestBuilder.BuildRequest(api, badCommand);
});
}
public void TestApiNull()
{
TestCommandBasic command = new();
Assert.Throws <ArgumentNullException>(() =>
{
Uri requestUri = ApiRequestBuilder.BuildRequest(null, command);
});
}
public void ThrowOnInvalidRequest2()
{
var client = ApiClientHelper.GetRealApiClient();
var builder = new ApiRequestBuilder();
var request = builder.GetProjectsRequest();
request.Request.Parameters[1].Name = "invalid-fake-param";
var res = client.GetObjects<ApiProject>(request);
}
public SyncClient(IApiClient client)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
_client = client;
_requestBuilder = new ApiRequestBuilder();
}
public async Task <ExternalIds> GetTvExternalIds(int tvId)
{
var apiRequest = new ApiRequestBuilder(_baseUri, $"tv/{tvId}/external_ids", HttpMethod.Get)
.AddQueryParam("api_key", _apiKey)
.AddQueryParam("language", LanguageCode)
.Build();
var externalIds = await _apiService.InvokeApiAsync <ExternalIds>(apiRequest);
return(externalIds);
}
public async Task <TvSeasonDetails> GetTvSeasonDetails(int tvId, int seasonNumber)
{
var apiRequest = new ApiRequestBuilder(_baseUri, $"tv/{tvId}/season/{seasonNumber}", HttpMethod.Get)
.AddQueryParam("api_key", _apiKey)
.AddQueryParam("language", LanguageCode)
.Build();
var tvSeasonDetails = await _apiService.InvokeApiAsync <TvSeasonDetails>(apiRequest);
return(tvSeasonDetails);
}
public void ThrowOnInvalidRequest2()
{
var client = ApiClientHelper.GetRealApiClient();
var builder = new ApiRequestBuilder();
var request = builder.GetProjectsRequest();
request.Request.Parameters[1].Name = "invalid-fake-param";
var res = client.GetObjects <ApiProject>(request);
}
/// <summary>
///
/// </summary>
/// <param name="authToken"></param>
/// <returns></returns>
public async Task <User> GetAccount(string authToken)
{
var apiRequest = new ApiRequestBuilder("https://plex.tv/users/account.json", "", HttpMethod.Get)
.AddPlexToken(authToken)
.AddRequestHeaders(GetClientIdentifierHeader())
.Build();
var account = await ApiService.InvokeApiAsync <PlexAccount>(apiRequest);
return(account?.User);
}
public async Task <MovieDetails> GetMovieDetails(int movieId)
{
var apiRequest = new ApiRequestBuilder(_baseUri, $"movie/{movieId}", HttpMethod.Get)
.AddQueryParam("api_key", _apiKey)
.AddQueryParam("language", LanguageCode)
.Build();
var movie = await _apiService.InvokeApiAsync <MovieDetails>(apiRequest);
return(movie);
}
public async Task <List <Resource> > GetResources(string authToken)
{
var apiRequest = new ApiRequestBuilder("https://plex.tv/pms/resources.xml", "", HttpMethod.Get)
.AddPlexToken(authToken)
.AddRequestHeaders(GetClientIdentifierHeader())
.Build();
ResourceContainer resourceContainer = await ApiService.InvokeApiAsync <ResourceContainer>(apiRequest);
return(resourceContainer?.Devices);
}
/// <summary>
/// Delete Collection from Plex
/// </summary>
/// <param name="authToken">Authentication Token</param>
/// <param name="plexServerHost">Full Uri of Plex Media Server Instance</param>
/// <param name="ratingKey">Rating Key of the Collection to delete</param>
/// <returns></returns>
public async Task DeleteCollection(string authToken, string plexServerHost, string ratingKey)
{
var apiRequest =
new ApiRequestBuilder(plexServerHost, "library/metadata/" + ratingKey, HttpMethod.Delete)
.AddPlexToken(authToken)
.AddRequestHeaders(GetClientIdentifierHeader())
.AcceptJson()
.Build();
await ApiService.InvokeApiAsync(apiRequest);
}
/// <summary>
/// Retuns all the Plex friends for this account
/// </summary>
/// <param name="authToken"></param>
/// <returns></returns>
public async Task <List <Friend> > GetFriends(string authToken)
{
var apiRequest = new ApiRequestBuilder("https://plex.tv/pms/friends/all", "", HttpMethod.Get)
.AddPlexToken(authToken)
.AddRequestHeaders(GetClientIdentifierHeader())
.Build();
FriendContainer friendContainer = await ApiService.InvokeApiAsync <FriendContainer>(apiRequest);
return(friendContainer?.Friends.ToList());
}
/// <summary>
/// http://[PMS_IP_Address]:32400/library/sections?X-Plex-Token=YourTokenGoesHere
/// Retrieves a list of servers tied to your Plex Account
/// </summary>
/// <param name="authToken">Authentication Token</param>
/// <returns></returns>
public async Task <List <Server> > GetServers(string authToken)
{
var apiRequest = new ApiRequestBuilder("https://plex.tv/pms/servers.xml", "", HttpMethod.Get)
.AddPlexToken(authToken)
.AddRequestHeaders(GetClientIdentifierHeader())
.Build();
ServerContainer serverContainer = await ApiService.InvokeApiAsync <ServerContainer>(apiRequest);
return(serverContainer?.Servers);
}
/// <inheritdoc/>
public async Task RefreshContent(string authToken, string plexServerHost)
{
var apiRequest =
new ApiRequestBuilder(plexServerHost, "sync/refreshContent", HttpMethod.Put)
.AddPlexToken(authToken)
.AddQueryParams(ClientUtilities.GetClientIdentifierHeader(this.clientOptions.ClientId))
.AcceptJson()
.Build();
await this.apiService.InvokeApiAsync(apiRequest);
}
/// <inheritdoc/>
public async Task CancelScanForNewItems(string authToken, string plexServerHost, string key)
{
var apiRequest =
new ApiRequestBuilder(plexServerHost, $"library/sections/{key}/refresh", HttpMethod.Delete)
.AddPlexToken(authToken)
.AddRequestHeaders(ClientUtilities.GetClientIdentifierHeader(this.clientOptions.ClientId))
.AcceptJson()
.Build();
await this.apiService.InvokeApiAsync(apiRequest);
}
/// <summary>
/// Get Pin
/// </summary>
/// <param name="pinId"></param>
/// <returns></returns>
public async Task <OAuthPin> GetAuthTokenFromOAuthPin(string pinId)
{
var apiRequest =
new ApiRequestBuilder(BaseUri, $"pins/{pinId}", HttpMethod.Get)
.AcceptJson()
.AddRequestHeaders(GetClientIdentifierHeader())
.Build();
var oauthPin = await ApiService.InvokeApiAsync <OAuthPin>(apiRequest);
return(oauthPin);
}
/// <summary>
///
/// </summary>
/// <param name="authToken">Authentication Token</param>
/// <param name="plexServerHost">Full Uri of Plex Media Server Instance</param>
/// <param name="ratingKey">Rating Key of the item</param>
public async Task ScrobbleItem(string authToken, string plexServerHost, string ratingKey)
{
var apiRequest = new ApiRequestBuilder(plexServerHost,
":/scrobble?identifier=com.plexapp.plugins.library&key=" + ratingKey,
HttpMethod.Get)
.AddPlexToken(authToken)
.AddRequestHeaders(GetClientIdentifierHeader())
.AcceptJson()
.Build();
await ApiService.InvokeApiAsync(apiRequest);
}
/// <summary>
/// http://[PMS_IP_Address]:32400/status/sessions?X-Plex-Token=YourTokenGoesHere
/// Retrieves a list of active sessions on the Plex Media Server instance
/// </summary>
/// <param name="authToken">Authentication Token</param>
/// <param name="plexServerHost">Full Uri of Plex Media Server Instance</param>
/// <returns></returns>
public async Task <List <Session> > GetSessions(string authToken, string plexServerHost)
{
var apiRequest = new ApiRequestBuilder(plexServerHost, "status/sessions", HttpMethod.Get)
.AddPlexToken(authToken)
.AddRequestHeaders(GetClientIdentifierHeader())
.AcceptJson()
.Build();
var sessionWrapper = await ApiService.InvokeApiAsync <SessionWrapper>(apiRequest);
return(sessionWrapper.SessionContainer.Sessions?.ToList());
}
/// <summary>
///
/// </summary>
/// <param name="authToken">Authentication Token</param>
/// <param name="plexServerHost">Plex Host Uri</param>
/// <returns></returns>
public async Task <PlexMediaContainer> GetPlexInfo(string authToken, string plexServerHost)
{
var apiRequest = new ApiRequestBuilder(plexServerHost, "", HttpMethod.Get)
.AddPlexToken(authToken)
.AddRequestHeaders(GetClientIdentifierHeader())
.AcceptJson()
.Build();
var plexMediaContainer = await ApiService.InvokeApiAsync <PlexMediaContainer>(apiRequest);
return(plexMediaContainer);
}
/// <summary>
///
/// </summary>
/// <param name="authToken">Authentication Token</param>
/// <param name="plexServerHost">Plex Host Uri</param>
/// <param name="metadataId">Metadata Unique Identifier</param>
/// <returns></returns>
public async Task <PlexMediaContainer> GetMetadata(string authToken, string plexServerHost, int metadataId)
{
var apiRequest = new ApiRequestBuilder(plexServerHost, $"library/metadata/{metadataId}", HttpMethod.Get)
.AddPlexToken(authToken)
.AddRequestHeaders(GetClientIdentifierHeader())
.AcceptJson()
.Build();
var plexMediaContainer = await _apiService.InvokeApiAsync <PlexMediaContainer>(apiRequest);
return(plexMediaContainer);
}
public void TestNoParams()
{
TestCommandBasic command = new();
Uri requestUri = ApiRequestBuilder.BuildRequest(api, command);
var queryCollection = QueryHelpers.ParseQuery(requestUri.Query);
AssertCommonQueryParams(queryCollection);
Assert.False(queryCollection.ContainsKey("Prop"));
Assert.False(queryCollection.ContainsKey("Prop1"));
}
