/// <inheritdoc />
public Task <LeaderboardResult> GetLeaderboardAsync(XboxLiveUser user, LeaderboardQuery query)
{
string skipToXboxUserId = null;
if (query.SkipResultToMe)
{
skipToXboxUserId = user.XboxUserId;
}
string requestPath;
if (string.IsNullOrEmpty(query.SocialGroup))
{
requestPath = CreateLeaderboardUrlPath(this.appConfig.PrimaryServiceConfigId, query.StatName, query.MaxItems, skipToXboxUserId, query.SkipResultsToRank, query.ContinuationToken);
}
else
{
requestPath = CreateSocialLeaderboardUrlPath(this.appConfig.PrimaryServiceConfigId, query.StatName, user.XboxUserId, query.MaxItems, skipToXboxUserId, query.SkipResultsToRank, query.ContinuationToken, query.SocialGroup);
}
XboxLiveHttpRequest request = XboxLiveHttpRequest.Create(HttpMethod.Get, leaderboardsBaseUri.ToString(), requestPath);
request.ContractVersion = leaderboardApiContract;
return(request.GetResponseWithAuth(user)
.ContinueWith(
responseTask =>
{
return this.HandleLeaderboardResponse(responseTask, query);
}));
}
public Task UpdateStatsValueDocument(XboxLiveUser user, StatsValueDocument statValuePostDocument)
{
string pathAndQuery = PathAndQueryStatSubpath(
user.XboxUserId,
this.config.PrimaryServiceConfigId,
false
);
XboxLiveHttpRequest req = XboxLiveHttpRequest.Create(HttpMethod.Post, this.statsWriteEndpoint, pathAndQuery);
var svdModel = new Models.StatsValueDocumentModel()
{
Revision = ++statValuePostDocument.Revision,
Timestamp = DateTime.Now,
Stats = new Models.Stats()
{
Title = new Dictionary <string, Models.Stat>()
}
};
svdModel.Stats.Title = statValuePostDocument.Stats.ToDictionary(
stat => stat.Key,
stat => new Models.Stat()
{
Value = stat.Value.Value
});
req.RequestBody = JsonConvert.SerializeObject(svdModel, serializerSettings);
req.XboxLiveAPI = XboxLiveAPIName.UpdateStatsValueDocument;
req.CallerContext = "StatsManager";
req.RetryAllowed = false;
return(req.GetResponseWithAuth(user));
}
internal string GetTitleStorageBlobMetadataUploadSubpath(
XboxLiveUser user, TitleStorageBlobMetadata blobMetadata, string continuationToken, bool finalBlock)
{
var pathBuilder = new StringBuilder();
pathBuilder.Append(this.GetTitleStorageBlobMetadataDownloadSubpath(user, blobMetadata, string.Empty));
var parameterList = new Dictionary <string, string>();
if (blobMetadata.ClientTimeStamp != null)
{
var clientTimestamp = blobMetadata.ClientTimeStamp.ToString();
parameterList.Add("clientFileTime", Uri.EscapeUriString(clientTimestamp));
}
if (!string.IsNullOrEmpty(blobMetadata.DisplayName))
{
parameterList.Add("displayName", Uri.EscapeUriString(blobMetadata.DisplayName));
}
if (!string.IsNullOrEmpty(continuationToken))
{
parameterList.Add("continuationToken", Uri.EscapeUriString(continuationToken));
}
if (blobMetadata.BlobType == TitleStorageBlobType.Binary)
{
parameterList.Add("finalBlock", finalBlock.ToString());
}
pathBuilder.Append(XboxLiveHttpRequest.GetQueryFromParams(parameterList));
return(pathBuilder.ToString());
}
private static async Task <UserResetJob> SubmitJobAsync(string sandbox, string scid, string xuid)
{
var job = new UserResetJob {
Sandbox = sandbox, Scid = scid
};
using (var submitRequest = new XboxLiveHttpRequest(true, scid, sandbox))
{
var response = await submitRequest.SendAsync(() =>
{
var requestMsg = new HttpRequestMessage(HttpMethod.Post, new Uri(baseUri, "submitJob"));
var requestContent = JsonConvert.SerializeObject(new JobSubmitReqeust(scid, xuid));
requestMsg.Content = new StringContent(requestContent);
requestMsg.Headers.Add("x-xbl-contract-version", "100");
return(requestMsg);
});
response.Response.EnsureSuccessStatusCode();
// remove "" if found one.
string responseContent = await response.Response.Content.ReadAsStringAsync();
job.JobId = responseContent.Trim(new char[] { '\\', '\"' });
job.CorrelationId = response.CorrelationId;
Log.WriteLog($"Submitting delete job for scid:{scid}, user:{xuid}, sandbox:{sandbox} succeeded. Jobid: {job.JobId}");
}
return(job);
}
protected async Task <XdtsTokenResponse> FetchXdtsToken(string aadToken, string scid, IEnumerable <string> sandboxes)
{
using (var tokenRequest = new XboxLiveHttpRequest())
{
HttpResponseMessage response = (await tokenRequest.SendAsync(() =>
{
var requestMsg = new HttpRequestMessage(HttpMethod.Post, this.AuthContext.XtdsEndpoint);
var requestContent = JsonConvert.SerializeObject(new XdtsTokenRequest(scid, sandboxes));
requestMsg.Content = new StringContent(requestContent);
// Add the aadToken header without validation as the framework
// does not like the values returned for aadTokens for MSA accounts.
requestMsg.Headers.TryAddWithoutValidation("Authorization", aadToken);
return(requestMsg);
})).Response;
response.EnsureSuccessStatusCode();
Log.WriteLog("Fetch xdts Token succeeded.");
var token = await response.Content.DeserializeJsonAsync <XdtsTokenResponse>();
string key = XdtsTokenCache.GetCacheKey(this.AuthContext.UserName, this.AuthContext.AccountSource, scid, sandboxes);
this.ETokenCache.Value.UpdateToken(key, token);
return(token);
}
}
/// <summary>
/// Downloads a savedgame from Connected Storage.
/// </summary>
/// <param name="xuid">The xuid of the user</param>
/// <param name="serviceConfigurationId">The service configuration ID (SCID) of the title</param>
/// <param name="sandbox">The target sandbox id for title storage</param>
/// <param name="pathAndFileName">Blob path and file name on XboxLive service.</param>
/// <returns>The byte array contains downloaded blob data</returns>
public static async Task <SavedGameV2Response> DownloadSavedGameAsync(ulong xuid, Guid serviceConfigurationId, string sandbox, string pathAndFileName)
{
using (var request = new XboxLiveHttpRequest(true, serviceConfigurationId, sandbox))
{
HttpResponseMessage response = (await request.SendAsync(() =>
{
var requestMsg = new HttpRequestMessage(HttpMethod.Get, new Uri(baseUri, $"/connectedstorage/users/xuid({xuid})/scids/{serviceConfigurationId}/savedgames/{pathAndFileName}"));
requestMsg.Headers.Add("x-xbl-contract-version", "1");
return(requestMsg);
})).Response;
response.EnsureSuccessStatusCode();
Log.WriteLog($"DownloadSavedGameAsync for xuid: {xuid}, scid: {serviceConfigurationId}, sandbox: {sandbox}");
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault();
using (StreamReader streamReader = new StreamReader(await response.Content.ReadAsStreamAsync()))
{
using (JsonTextReader jsonTextReader = new JsonTextReader(streamReader))
{
return(jsonSerializer.Deserialize <SavedGameV2Response>(jsonTextReader));
}
}
}
}
/// <summary>
/// Deletes a blob from title storage.
/// </summary>
/// <param name="user">The Xbox User of the title storage to enumerate. Ignored when enumerating GlobalStorage.</param>
/// <param name="blobMetadata">The blob metadata for the title storage blob to delete.</param>
/// <param name="blobQueryProperties">An instance of the <see cref="BlobQueryProperties"/> class with properties of the download query.</param>
/// <returns>An empty task.</returns>
public Task DeleteBlobAsync(XboxLiveUser user, TitleStorageBlobMetadata blobMetadata, BlobQueryProperties blobQueryProperties)
{
var eTagMatchCondition = blobQueryProperties.ETagMatchCondition == TitleStorageETagMatchCondition.IfMatch ?
TitleStorageETagMatchCondition.IfMatch : TitleStorageETagMatchCondition.NotUsed;
var subPathAndQueryResult = this.GetTitleStorageBlobMetadataDownloadSubpath(user, blobMetadata, string.Empty);
if (string.IsNullOrEmpty(subPathAndQueryResult))
{
return(Task.FromResult <object>(null));
}
var httpRequest = XboxLiveHttpRequest.Create(HttpMethod.Delete, TitleStorageBaseUri.ToString(), subPathAndQueryResult);
httpRequest.ContractVersion = TitleStorageApiContract;
httpRequest.ContentType = ContentTypeHeaderValue;
httpRequest.XboxLiveAPI = XboxLiveAPIName.DeleteBlob;
SetEtagHeader(httpRequest, blobMetadata.ETag, eTagMatchCondition);
return(httpRequest.GetResponseWithAuth(user).ContinueWith(responseTask =>
{
if (responseTask.Result.ErrorCode != 0)
{
throw new Exception("Invalid HTTP received on delete. Error Message: " + responseTask.Result.ErrorMessage);
}
}));
}
private Task <List <XboxSocialUser> > GetSocialGraph(XboxLiveUser user, SocialManagerExtraDetailLevel decorations, string relationshipType, IList <string> xboxLiveUsers)
{
bool isBatch = xboxLiveUsers != null && xboxLiveUsers.Count > 0;
string pathAndQuery = this.CreateSocialGraphSubpath(user.XboxUserId, decorations, relationshipType, isBatch);
XboxLiveHttpRequest request = XboxLiveHttpRequest.Create(
isBatch ? HttpMethod.Post : HttpMethod.Get,
this.peopleHubEndpoint,
pathAndQuery);
request.ContractVersion = "1";
if (isBatch)
{
JObject postBody = new JObject(new JProperty("xuids", xboxLiveUsers));
request.RequestBody = postBody.ToString(Formatting.None);
}
request.XboxLiveAPI = XboxLiveAPIName.GetSocialGraph;
request.CallerContext = "SocialManager";
return(request.GetResponseWithAuth(user)
.ContinueWith(responseTask =>
{
var response = responseTask.Result;
JObject responseBody = JObject.Parse(response.ResponseBodyString);
List <XboxSocialUser> users = responseBody["people"].ToObject <List <XboxSocialUser> >();
return users;
}));
}
/// <summary>
/// Downloads atom from Connected Storage.
/// </summary>
/// <param name="xuid">The xuid of the user</param>
/// <param name="serviceConfigurationId">The service configuration ID (SCID) of the title</param>
/// <param name="sandbox">The target sandbox id for title storage</param>
/// <param name="pathAndFileName">Blob path and file name to store on XboxLive service.(example: "foo\bar\blob.txt")</param>
/// <returns>The byte array contains downloaded blob data</returns>
public static async Task <byte[]> DownloadAtomAsync(ulong xuid, Guid serviceConfigurationId, string sandbox, string pathAndFileName)
{
using (var request = new XboxLiveHttpRequest(true, serviceConfigurationId, sandbox))
{
HttpResponseMessage response = (await request.SendAsync(() =>
{
var requestMsg = new HttpRequestMessage(HttpMethod.Get, new Uri(baseUri, $"/connectedstorage/users/xuid({xuid})/scids/{serviceConfigurationId}/{pathAndFileName},binary"));
requestMsg.Headers.Add("x-xbl-contract-version", "1");
requestMsg.Headers.AcceptEncoding.Add(StringWithQualityHeaderValue.Parse("gzip"));
return(requestMsg);
})).Response;
response.EnsureSuccessStatusCode();
Log.WriteLog($"DownloadAtomAsync for xuid: {xuid}, scid: {serviceConfigurationId}, sandbox: {sandbox}");
// if the response came gzip encoded, we need to decompress it
if (response.Content.Headers.ContentEncoding.FirstOrDefault() == "gzip")
{
using (GZipStream gzipStream = new GZipStream(await response.Content.ReadAsStreamAsync(), CompressionMode.Decompress))
{
using (var memoryStream = new MemoryStream())
{
await gzipStream.CopyToAsync(memoryStream);
return(memoryStream.ToArray());
}
}
}
else
{
return(await response.Content.ReadAsByteArrayAsync());
}
}
}
/// <summary>
/// Gets title storage quota information for the specified service configuration and storage type.
/// For user storage types (TrustedPlatform and Json) the request will be made for the calling user's
/// Xbox user Id.
/// </summary>
/// <param name="user">The Xbox User of the title storage to enumerate. Ignored when enumerating GlobalStorage.</param>
/// <param name="storageType">Type of the storage type</param>
/// <returns>An instance of the <see cref="TitleStorageQuota"/> class with the amount of storage space allocated and used.</returns>
public Task <TitleStorageQuota> GetQuotaAsync(XboxLiveUser user, TitleStorageType storageType)
{
var subQuery = this.GetTitleStorageSubpath(user, storageType);
var httpRequest = XboxLiveHttpRequest.Create(HttpMethod.Get, TitleStorageBaseUri.ToString(), subQuery);
httpRequest.ContractVersion = TitleStorageApiContract;
return(httpRequest.GetResponseWithAuth(user).ContinueWith(
responseTask => this.HandleStorageQuoteResponse(responseTask, storageType)));
}
internal static void SetEtagHeader(
XboxLiveHttpRequest httpRequest, string eTag, TitleStorageETagMatchCondition eTagMatchCondition)
{
if (eTagMatchCondition != TitleStorageETagMatchCondition.NotUsed)
{
if (!string.IsNullOrEmpty(eTag))
{
httpRequest.SetCustomHeader(ETagHeaderName, eTag);
var headerToUse = eTagMatchCondition == TitleStorageETagMatchCondition.IfMatch ? IfMatchHeaderName : IfNoneHeaderName;
httpRequest.SetCustomHeader(headerToUse, eTag);
}
}
}
private Task SetPresenceHelper(XboxLiveUser user, bool isUserActiveInTitle, PresenceData presenceData)
{
var subQuery = SetPresenceSubPath(user, isUserActiveInTitle);
var httpRequest = XboxLiveHttpRequest.Create(HttpMethod.Post, UserPresenceBaseUri.ToString(), subQuery);
httpRequest.ContractVersion = PresenceWriterApiContract;
httpRequest.XboxLiveAPI = XboxLiveAPIName.SetPresenceHelper;
httpRequest.RequestBody = JsonSerialization.ToJson(new SimplePresenceRequest {
State = isUserActiveInTitle? "active":"inactive"
});
return(httpRequest.GetResponseWithAuth(user).ContinueWith(
responseTask => HandleSetPresenceResponse(user, responseTask.Result)));
}
/// <summary>
/// Get profile information for a user.
/// </summary>
/// <param name="user">The user to get profile information for.</param>
/// <param name="decorations">The additional detail to include in the response</param>
/// <returns>Social profile information for the user.</returns>
public Task <XboxSocialUser> GetProfileInfo(XboxLiveUser user, SocialManagerExtraDetailLevel decorations)
{
string path = "/users/me/people/xuids(" + user.XboxUserId + ")";
path += "/decoration/";
if ((decorations | SocialManagerExtraDetailLevel.None) != SocialManagerExtraDetailLevel.None)
{
if (decorations.HasFlag(SocialManagerExtraDetailLevel.TitleHistory))
{
path += "titlehistory(" + this.appConfig.TitleId + "),";
}
if (decorations.HasFlag(SocialManagerExtraDetailLevel.PreferredColor))
{
path += "preferredcolor,";
}
}
// We always ask for presence detail.
path += "presenceDetail";
XboxLiveHttpRequest request = XboxLiveHttpRequest.Create(
HttpMethod.Get,
this.peopleHubEndpoint,
path);
request.ContractVersion = "1";
request.XboxLiveAPI = XboxLiveAPIName.GetProfileInfo;
request.CallerContext = "SocialManager";
return(request.GetResponseWithAuth(user)
.ContinueWith(responseTask =>
{
if (responseTask.IsFaulted)
{
throw new XboxException("PeopleHub call failed with " + responseTask.Exception);
}
var response = responseTask.Result;
if (response.HttpStatus != 200)
{
throw new XboxException("PeopleHub call failed with " + response.HttpStatus);
}
JObject responseBody = JObject.Parse(response.ResponseBodyString);
List <XboxSocialUser> users = responseBody["people"].ToObject <List <XboxSocialUser> >();
return users[0];
}));
}
/// <summary>
/// Deletes a blob from title storage.
/// </summary>
/// <param name="serviceConfigurationId">The service configuration ID (SCID) of the title</param>
/// <param name="sandbox">The target sandbox id for title storage</param>
/// <param name="pathAndFileName">Blob path and file name to store on XboxLive service.(example: "foo\bar\blob.txt")</param>
/// <param name="blobType">Title storage blob type</param>
public static async Task DeleteGlobalStorageBlobAsync(string serviceConfigurationId, string sandbox, string pathAndFileName, TitleStorageBlobType blobType)
{
using (var request = new XboxLiveHttpRequest(true, serviceConfigurationId, sandbox))
{
var response = await request.SendAsync(() =>
{
var requestMsg = new HttpRequestMessage(HttpMethod.Delete, new Uri(baseUri, $"/global/scids/{serviceConfigurationId}/data/{pathAndFileName},{blobType.ToString().ToLower()}"));
requestMsg.Headers.Add("x-xbl-contract-version", "1");
return(requestMsg);
});
Log.WriteLog($"DeleteGlobalStorageBlobAsync for scid: {serviceConfigurationId}, sandbox: {sandbox}");
}
}
public Task <PermissionCheckResult> CheckPermissionWithTargetUserAsync(XboxLiveUser user, string permissionId, string targetXboxUserId)
{
XboxLiveHttpRequest req = XboxLiveHttpRequest.Create(
HttpMethod.Get,
this.privacyEndpoint,
string.Format("/users/xuid({0})/permission/validate?setting={1}&target=xuid({2})", user.XboxUserId, permissionId, targetXboxUserId));
return(req.GetResponseWithAuth(user)
.ContinueWith(responseTask =>
{
var response = responseTask.Result;
JObject responseBody = JObject.Parse(response.ResponseBodyString);
PermissionCheckResult result = responseBody.ToObject <PermissionCheckResult>();
return result;
}));
}
/// <summary>
/// Downloads blob data from title storage.
/// </summary>
/// <param name="serviceConfigurationId">The service configuration ID (SCID) of the title</param>
/// <param name="sandbox">The target sandbox id for title storage</param>
/// <param name="pathAndFileName">Blob path and file name to store on XboxLive service.(example: "foo\bar\blob.txt")</param>
/// <param name="blobType">Title storage blob type</param>
/// <returns>The byte array contains downloaded blob data</returns>
public static async Task <byte[]> DownloadGlobalStorageBlobAsync(string serviceConfigurationId, string sandbox, string pathAndFileName, TitleStorageBlobType blobType)
{
using (var request = new XboxLiveHttpRequest(true, serviceConfigurationId, sandbox))
{
HttpResponseMessage response = (await request.SendAsync(() =>
{
var requestMsg = new HttpRequestMessage(HttpMethod.Get, new Uri(baseUri, $"/global/scids/{serviceConfigurationId}/data/{pathAndFileName},{blobType.ToString().ToLower()}"));
requestMsg.Headers.Add("x-xbl-contract-version", "1");
return(requestMsg);
})).Response;
response.EnsureSuccessStatusCode();
Log.WriteLog($"DownloadGlobalStorageBlobAsync for scid: {serviceConfigurationId}, sandbox: {sandbox}");
return(await response.Content.ReadAsByteArrayAsync());
}
}
public Task <List <MultiplePermissionsCheckResult> > CheckMultiplePermissionsWithMultipleTargetUsersAsync(XboxLiveUser user, IList <string> permissionIds, IList <string> targetXboxUserIds)
{
XboxLiveHttpRequest req = XboxLiveHttpRequest.Create(
HttpMethod.Post,
this.privacyEndpoint,
string.Format("/users/xuid({0})/permission/validate", user.XboxUserId));
Models.PrivacySettingsRequest reqBodyObject = new Models.PrivacySettingsRequest(permissionIds, targetXboxUserIds);
req.RequestBody = JsonSerialization.ToJson(reqBodyObject);
return(req.GetResponseWithAuth(user)
.ContinueWith(responseTask =>
{
var response = responseTask.Result;
JObject responseBody = JObject.Parse(response.ResponseBodyString);
List <MultiplePermissionsCheckResult> results = responseBody["responses"].ToObject <List <MultiplePermissionsCheckResult> >();
return results;
}));
}
internal static async Task <ListTitleDataResponse> ListSavedGamesAsync(ulong xuid, string serviceConfigurationId, string sandbox, string path, uint maxItems,
uint skipItems, string continuationToken)
{
using (var request = new XboxLiveHttpRequest(true, serviceConfigurationId, sandbox))
{
var uriBuilder = new UriBuilder(baseUri)
{
Path = $"/connectedstorage/users/xuid({xuid})/scids/{serviceConfigurationId}/{path}"
};
AppendPagingInfo(ref uriBuilder, maxItems, skipItems, continuationToken);
HttpResponseMessage response = (await request.SendAsync(() =>
{
var requestMsg = new HttpRequestMessage(HttpMethod.Get, uriBuilder.Uri);
requestMsg.Headers.Add("x-xbl-contract-version", "1");
return(requestMsg);
})).Response;
// Return empty list on 404
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(new ListTitleDataResponse());
}
response.EnsureSuccessStatusCode();
Log.WriteLog($"ListSavedGamesAsync for xuid: {xuid}, scid: {serviceConfigurationId}, sandbox: {sandbox}");
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault();
using (StreamReader streamReader = new StreamReader(await response.Content.ReadAsStreamAsync()))
{
using (JsonTextReader jsonTextReader = new JsonTextReader(streamReader))
{
return(jsonSerializer.Deserialize <ListTitleDataResponse>(jsonTextReader));
}
}
}
}
public Task UpdateStatsValueDocument(StatsValueDocument statValuePostDocument)
{
string endpoint = XboxLiveEndpoint.GetEndpointForService("statswrite", this.config);
string pathAndQuery = PathAndQueryStatSubpath(
this.context.User.XboxUserId,
this.config.ServiceConfigurationId,
false
);
XboxLiveHttpRequest req = XboxLiveHttpRequest.Create(this.settings, "POST", endpoint, pathAndQuery);
var svdModel = new Models.StatsValueDocumentModel()
{
Revision = statValuePostDocument.Revision,
Timestamp = DateTime.Now,
Stats = new Models.Stats()
{
Title = new Dictionary <string, Models.Stat>()
}
};
svdModel.Stats.Title = statValuePostDocument.Stats.ToDictionary(
stat => stat.Key,
stat => new Models.Stat()
{
Value = stat.Value.Value
});
req.RequestBody = JsonConvert.SerializeObject(svdModel, new JsonSerializerSettings
{
});
return(req.GetResponseWithAuth(this.context.User, HttpCallResponseBodyType.JsonBody).ContinueWith(task =>
{
XboxLiveHttpResponse response = task.Result;
if (response.ErrorCode == 0)
{
++statValuePostDocument.Revision;
}
}));
}
private static async Task <JobStatusResponse> CheckJobStatus(UserResetJob userResetJob)
{
using (var submitRequest = new XboxLiveHttpRequest(true, userResetJob.Scid, userResetJob.Sandbox))
{
XboxLiveHttpResponse xblResponse = await submitRequest.SendAsync(() =>
{
var requestMsg = new HttpRequestMessage(HttpMethod.Get, new Uri(baseUri, "jobs/" + userResetJob.JobId));
if (!string.IsNullOrEmpty(userResetJob.CorrelationId))
{
requestMsg.Headers.Add("X-XblCorrelationId", userResetJob.CorrelationId);
}
requestMsg.Headers.Add("x-xbl-contract-version", "100");
return(requestMsg);
});
// There is a chance if polling too early for job status, it will return 400.
// We threat it as job queue and wait for next poll.
if (xblResponse.Response.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
return(new JobStatusResponse
{
Status = "Queued",
JobId = userResetJob.JobId
});
}
// Throw HttpRequestExcetpion for other HTTP status code
xblResponse.Response.EnsureSuccessStatusCode();
string responseConent = await xblResponse.Response.Content.ReadAsStringAsync();
var jobstatus = JsonConvert.DeserializeObject <JobStatusResponse>(responseConent);
Log.WriteLog($"Checking {userResetJob.JobId} job stauts: {jobstatus.Status}");
return(jobstatus);
}
}
public Task <StatsValueDocument> GetStatsValueDocument(XboxLiveUser user)
{
string pathAndQuery = PathAndQueryStatSubpath(
user.XboxUserId,
this.config.PrimaryServiceConfigId,
false
);
XboxLiveHttpRequest req = XboxLiveHttpRequest.Create(HttpMethod.Get, this.statsReadEndpoint, pathAndQuery);
return(req.GetResponseWithAuth(user).ContinueWith(task =>
{
XboxLiveHttpResponse response = task.Result;
var svdModel = JsonConvert.DeserializeObject <Models.StatsValueDocumentModel>(response.ResponseBodyString);
var svd = new StatsValueDocument(svdModel.Stats.Title, svdModel.Revision)
{
State = StatsValueDocument.StatValueDocumentState.Loaded,
User = user
};
return svd;
}));
}
public Task <StatsValueDocument> GetStatsValueDocument()
{
string endpoint = XboxLiveEndpoint.GetEndpointForService("statsread", this.config);
string pathAndQuery = PathAndQueryStatSubpath(
this.context.User.XboxUserId,
this.config.ServiceConfigurationId,
false
);
XboxLiveHttpRequest req = XboxLiveHttpRequest.Create(this.settings, "GET", endpoint, pathAndQuery);
return(req.GetResponseWithAuth(this.context.User, HttpCallResponseBodyType.JsonBody).ContinueWith(task =>
{
XboxLiveHttpResponse response = task.Result;
var svdModel = JsonConvert.DeserializeObject <Models.StatsValueDocumentModel>(response.ResponseBodyJson);
var svd = new StatsValueDocument(svdModel.Stats.Title)
{
Revision = svdModel.Revision
};
return svd;
}));
}
internal Task <LeaderboardResult> GetLeaderboardInternal(string xuid, string serviceConfigurationId, string leaderboardName, string socialGroup, LeaderboardQuery query, LeaderboardRequestType leaderboardType)
{
string requestPath = "";
string skipToXboxUserId = null;
if (query.SkipResultToMe)
{
skipToXboxUserId = userContext.XboxUserId;
}
if (leaderboardType == LeaderboardRequestType.Social)
{
requestPath = CreateSocialLeaderboardUrlPath(serviceConfigurationId, leaderboardName, xuid, query.MaxItems, skipToXboxUserId, query.SkipResultsToRank, query.ContinuationToken, socialGroup);
}
else
{
requestPath = CreateLeaderboardUrlPath(serviceConfigurationId, leaderboardName, xuid, query.MaxItems, skipToXboxUserId, query.SkipResultsToRank, query.ContinuationToken, socialGroup);
}
XboxLiveHttpRequest request = XboxLiveHttpRequest.Create(xboxLiveContextSettings, HttpMethod.Get, leaderboardsBaseUri.ToString(), requestPath);
request.ContractVersion = leaderboardAPIContract;
return(request.GetResponseWithAuth(userContext, HttpCallResponseBodyType.JsonBody)
.ContinueWith(
responseTask =>
{
var leaderboardRequestType = LeaderboardRequestType.Global;
if (socialGroup != null)
{
leaderboardRequestType = LeaderboardRequestType.Social;
}
LeaderboardRequest leaderboardRequest = new LeaderboardRequest(leaderboardRequestType, leaderboardName);
LeaderboardQuery nextQuery = new LeaderboardQuery(query);
nextQuery.StatName = leaderboardName;
nextQuery.SocialGroup = socialGroup;
return this.HandleLeaderboardResponse(leaderboardRequest, responseTask, nextQuery);
}));
}
/// <summary>
/// Get title global storage quota information.
/// </summary>
/// <param name="serviceConfigurationId">The service configuration ID (SCID) of the title</param>
/// <param name="sandbox">The target sandbox id for title storage</param>
/// <returns>GlobalStorageQuotaInfo object contains quota info</returns>
public static async Task <GlobalStorageQuotaInfo> GetGlobalStorageQuotaAsync(string serviceConfigurationId, string sandbox)
{
using (var request = new XboxLiveHttpRequest(true, serviceConfigurationId, sandbox))
{
HttpResponseMessage response = (await request.SendAsync(() =>
{
var requestMsg = new HttpRequestMessage(HttpMethod.Get, new Uri(baseUri, "/global/scids/" + serviceConfigurationId));
requestMsg.Headers.Add("x-xbl-contract-version", "1");
return(requestMsg);
})).Response;
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
JObject storageQuota = JObject.Parse(content);
GlobalStorageQuotaInfo info = storageQuota["quotaInfo"].ToObject <GlobalStorageQuotaInfo>();
Log.WriteLog($"GetGlobalStorageQuotaAsync for scid: {serviceConfigurationId}, sandbox: {sandbox}");
return(info);
}
}
internal Task <TitleStorageBlobMetadataResult> InternalGetBlobMetadata(
XboxLiveUser user,
TitleStorageType storageType,
string blobPath,
uint skipItems,
uint maxItems,
string continuationToken = "")
{
string subPathAndQueryResult = this.GetTitleStorageBlobMetadataSubpath(
user,
storageType,
blobPath,
skipItems,
maxItems,
continuationToken);
var httpRequest = XboxLiveHttpRequest.Create(HttpMethod.Get, TitleStorageBaseUri.ToString(), subPathAndQueryResult);
httpRequest.ContractVersion = TitleStorageApiContract;
return(httpRequest.GetResponseWithAuth(user)
.ContinueWith(
responseTask => this.HandleBlobMetadataResult(user, responseTask, storageType, blobPath)));
}
/// <summary>
/// Get profile information for a user.
/// </summary>
/// <param name="user">The user to get profile information for.</param>
/// <param name="decorations">The additional detail to include in the response</param>
/// <returns>Social profile information for the user.</returns>
public Task <XboxSocialUser> GetProfileInfo(XboxLiveUser user, SocialManagerExtraDetailLevel decorations)
{
string path = "/users/me/people/xuids(" + user.XboxUserId + ")";
path += "/decoration/";
if ((decorations | SocialManagerExtraDetailLevel.None) != SocialManagerExtraDetailLevel.None)
{
if (decorations.HasFlag(SocialManagerExtraDetailLevel.TitleHistory))
{
path += "titlehistory(" + this.appConfig.TitleId + "),";
}
if (decorations.HasFlag(SocialManagerExtraDetailLevel.PreferredColor))
{
path += "preferredcolor,";
}
}
// We always ask for presence detail.
path += "presenceDetail";
XboxLiveHttpRequest request = XboxLiveHttpRequest.Create(
this.httpCallSettings,
HttpMethod.Get,
this.peopleHubHost,
path);
request.ContractVersion = "1";
return(request.GetResponseWithAuth(user, HttpCallResponseBodyType.JsonBody)
.ContinueWith(responseTask =>
{
var response = responseTask.Result;
JObject responseBody = JObject.Parse(response.ResponseBodyString);
List <XboxSocialUser> users = responseBody["people"].ToObject <List <XboxSocialUser> >();
return users[0];
}));
}
internal static void AppendPagingInfo(
StringBuilder stringBuilder, uint skipItems, uint maxItems, string continuationToken)
{
var parameterList = new Dictionary <string, string>();
if (maxItems > 0)
{
parameterList.Add("maxItems", Convert.ToString(maxItems));
}
if (string.IsNullOrEmpty(continuationToken))
{
if (skipItems > 0)
{
parameterList.Add("skipItems", Convert.ToString(skipItems));
}
}
else
{
parameterList.Add("continuationToken", continuationToken);
}
stringBuilder.Append(XboxLiveHttpRequest.GetQueryFromParams(parameterList));
}
public Task <List <XboxUserProfile> > GetUserProfilesAsync(XboxLiveUser user, List <string> xboxUserIds)
{
if (xboxUserIds == null)
{
throw new ArgumentNullException("xboxUserIds");
}
if (xboxUserIds.Count == 0)
{
throw new ArgumentOutOfRangeException("xboxUserIds", "Empty list of user ids");
}
if (XboxLive.UseMockServices)
{
Random rand = new Random();
List <XboxUserProfile> outputUsers = new List <XboxUserProfile>(xboxUserIds.Count);
foreach (string xuid in xboxUserIds)
{
// generate a fake dev gamertag
string gamertag = "2 dev " + rand.Next(10000);
XboxUserProfile profile = new XboxUserProfile()
{
XboxUserId = xuid,
ApplicationDisplayName = gamertag,
ApplicationDisplayPictureResizeUri = new Uri("http://images-eds.xboxlive.com/image?url=z951ykn43p4FqWbbFvR2Ec.8vbDhj8G2Xe7JngaTToBrrCmIEEXHC9UNrdJ6P7KI4AAOijCgOA3.jozKovAH98vieJP1ResWJCw2dp82QtambLRqzQbSIiqrCug0AvP4&format=png"),
GameDisplayName = gamertag,
GameDisplayPictureResizeUri = new Uri("http://images-eds.xboxlive.com/image?url=z951ykn43p4FqWbbFvR2Ec.8vbDhj8G2Xe7JngaTToBrrCmIEEXHC9UNrdJ6P7KI4AAOijCgOA3.jozKovAH98vieJP1ResWJCw2dp82QtambLRqzQbSIiqrCug0AvP4&format=png"),
Gamerscore = rand.Next(250000).ToString(),
Gamertag = gamertag
};
outputUsers.Add(profile);
}
return(Task.FromResult(outputUsers));
}
else
{
XboxLiveHttpRequest req = XboxLiveHttpRequest.Create(HttpMethod.Post, profileEndpoint, "/users/batch/profile/settings");
req.ContractVersion = "2";
req.ContentType = "application/json; charset=utf-8";
Models.ProfileSettingsRequest reqBodyObject = new Models.ProfileSettingsRequest(xboxUserIds, true);
req.RequestBody = JsonSerialization.ToJson(reqBodyObject);
req.XboxLiveAPI = XboxLiveAPIName.GetUserProfiles;
return(req.GetResponseWithAuth(user).ContinueWith(task =>
{
XboxLiveHttpResponse response = task.Result;
Models.ProfileSettingsResponse responseBody = new Models.ProfileSettingsResponse();
responseBody = JsonSerialization.FromJson <Models.ProfileSettingsResponse>(response.ResponseBodyString);
List <XboxUserProfile> outputUsers = new List <XboxUserProfile>();
foreach (Models.ProfileUser entry in responseBody.profileUsers)
{
XboxUserProfile profile = new XboxUserProfile()
{
XboxUserId = entry.id,
Gamertag = entry.Gamertag(),
GameDisplayName = entry.GameDisplayName(),
GameDisplayPictureResizeUri = new Uri(entry.GameDisplayPic()),
ApplicationDisplayName = entry.AppDisplayName(),
ApplicationDisplayPictureResizeUri = new Uri(entry.AppDisplayPic()),
Gamerscore = entry.Gamerscore()
};
outputUsers.Add(profile);
}
return outputUsers;
}));
}
}
/// <summary>
/// Downloads blob data from title storage.
/// </summary>
/// <param name="user">The Xbox User of the title storage to enumerate. Ignored when enumerating GlobalStorage.</param>
/// <param name="blobMetadata">The blob metadata for the title storage blob to download.</param>
/// <param name="blobQueryProperties">An instance of the <see cref="BlobQueryProperties"/> class with properties of the download query.</param>
/// <returns>An instance of the <see cref="TitleStorageBlobResult"/> containing the blob content and an updated
/// <see cref="TitleStorageBlobMetadata"/> object.</returns>
public Task <TitleStorageBlobResult> DownloadBlobAsync(
XboxLiveUser user,
TitleStorageBlobMetadata blobMetadata,
BlobQueryProperties blobQueryProperties)
{
var blobBuffer = new List <byte>();
var resultBlocBlobMetadata = new TitleStorageBlobMetadata(
blobMetadata.StorageType, blobMetadata.BlobPath,
blobMetadata.BlobType, blobMetadata.DisplayName, blobMetadata.ETag);
var preferredDownloadBlockSize =
blobQueryProperties.PreferredBlockSize < MinDownloadBlockSize ?
MinDownloadBlockSize :
blobQueryProperties.PreferredBlockSize;
var isBinaryData = (blobMetadata.BlobType == TitleStorageBlobType.Binary);
var isDownloading = true;
uint startByte = 0;
var subPathAndQueryResult = this.GetTitleStorageBlobMetadataDownloadSubpath(
user, blobMetadata, blobQueryProperties.SelectQuery);
while (isDownloading)
{
var httpRequest = XboxLiveHttpRequest.Create(HttpMethod.Get, TitleStorageBaseUri.ToString(), subPathAndQueryResult);
httpRequest.ContractVersion = TitleStorageApiContract;
httpRequest.ContentType = ContentTypeHeaderValue;
httpRequest.LongHttpCall = true;
httpRequest.ResponseBodyType = HttpCallResponseBodyType.VectorBody;
SetEtagHeader(httpRequest, blobMetadata.ETag, blobQueryProperties.ETagMatchCondition);
if (isBinaryData)
{
httpRequest.SetRangeHeader(startByte, startByte + preferredDownloadBlockSize);
}
httpRequest.XboxLiveAPI = XboxLiveAPIName.DownloadBlob;
httpRequest.GetResponseWithAuth(user).ContinueWith(responseTask =>
{
var response = responseTask.Result;
if (response.ErrorCode == 0)
{
var responseVector = response.ResponseBodyVector;
if (responseVector.Length > 0)
{
blobBuffer.AddRange(responseVector);
}
startByte += (uint)responseVector.Length;
if (!isBinaryData || responseVector.Length < preferredDownloadBlockSize)
{
isDownloading = false;
resultBlocBlobMetadata.SetBlobMetadataProperties((uint)(responseVector.Length), response.ETag);
}
}
}).Wait();
}
var resultBlobMetadataResult = new TitleStorageBlobResult(resultBlocBlobMetadata, blobBuffer.ToArray());
return(Task.FromResult(resultBlobMetadataResult));
}
/// <summary>
/// Upload blob data to title storage.
/// </summary>
/// <param name="user">The Xbox User of the title storage to enumerate. Ignored when enumerating GlobalStorage.</param>
/// <param name="blobMetadata">The blob metadata for the title storage blob to upload.</param>
/// <param name="blobBuffer">The Blob content to be uploaded.</param>
/// <param name="blobQueryProperties">An instance of the <see cref="BlobQueryProperties"/> class with properties of the upload query.</param>
/// <returns>An instance of the <see cref="TitleStorageBlobMetadata"/> class with updated ETag and Length Properties.</returns>
public Task <TitleStorageBlobMetadata> UploadBlobAsync(XboxLiveUser user, TitleStorageBlobMetadata blobMetadata, List <byte> blobBuffer, BlobQueryProperties blobQueryProperties)
{
if (blobBuffer == null)
{
throw new Exception("Blob buffer is null");
}
if (blobBuffer.Count == 0)
{
throw new Exception("Blob Buffer is empty");
}
var preferredUploadBlockSize = blobQueryProperties.PreferredBlockSize < MinUploadBlockSize ? MinUploadBlockSize : blobQueryProperties.PreferredBlockSize;
preferredUploadBlockSize = blobQueryProperties.PreferredBlockSize > MaxUploadBlockSize ? MaxUploadBlockSize : preferredUploadBlockSize;
var resultBlocBlobMetadata = new TitleStorageBlobMetadata(blobMetadata.StorageType, blobMetadata.BlobPath,
blobMetadata.BlobType, blobMetadata.DisplayName, blobMetadata.ETag);
var isBinaryData = (blobMetadata.BlobType == TitleStorageBlobType.Binary);
var dataChunk = new List <byte>();
uint start = 0;
var continuationToken = string.Empty;
while (start < blobBuffer.Count)
{
dataChunk.Clear();
bool isFinalBlock;
if (isBinaryData)
{
var count = (uint)(blobBuffer.Count) - start;
if (count > preferredUploadBlockSize)
{
count = preferredUploadBlockSize;
}
for (var index = 0; index < count; index++)
{
dataChunk.Add(blobBuffer[(int)(index + start)]);
}
start += count;
isFinalBlock = start == blobBuffer.Count;
}
else
{
dataChunk = blobBuffer;
start = (uint)(dataChunk.Count);
isFinalBlock = true;
}
var subpathAndQueryResult = this.GetTitleStorageBlobMetadataUploadSubpath(user, blobMetadata, continuationToken, isFinalBlock);
var httpRequest = XboxLiveHttpRequest.Create(HttpMethod.Put, TitleStorageBaseUri.ToString(), subpathAndQueryResult);
httpRequest.ContractVersion = TitleStorageApiContract;
httpRequest.ContentType = ContentTypeHeaderValue;
httpRequest.LongHttpCall = true;
SetEtagHeader(httpRequest, blobMetadata.ETag, blobQueryProperties.ETagMatchCondition);
var encoding = Encoding.UTF8;
httpRequest.RequestBody = encoding.GetString(dataChunk.ToArray());
httpRequest.XboxLiveAPI = XboxLiveAPIName.UploadBlob;
httpRequest.RetryAllowed = false;
var localIsFinalBlock = isFinalBlock;
httpRequest.GetResponseWithAuth(user).ContinueWith(responseTask =>
{
var json = responseTask.Result.ResponseBodyString;
continuationToken = string.Empty;
if (responseTask.Result.ErrorCode == 0 && !string.IsNullOrEmpty(json))
{
var pagingInfo = JsonSerialization.FromJson <PagingInfo>(json);
continuationToken = pagingInfo.ContinuationToken;
}
if (responseTask.Result.ErrorCode == 0 && localIsFinalBlock)
{
resultBlocBlobMetadata.SetBlobMetadataProperties((uint)(blobBuffer.Count), responseTask.Result.ETag);
}
}).Wait();
}
return(Task.FromResult(resultBlocBlobMetadata));
}
