private async Task <UploadImageResponse> Upload(MemoryStream dataStream)
{
UploadImageResponse uploadImageResponsePost = await _imageServiceClient.UploadImage(dataStream);
_imagesToCleanup.Add(uploadImageResponsePost);
return(uploadImageResponsePost);
}
public override Task <UploadImageResponse> UploadImage(UploadImageRequest request, ServerCallContext context)
{
var resp = new UploadImageResponse();
var accessToken = _redis.StringGet(CacheKey.UserAccessTokenPrefix + request.AppId);
if (accessToken.HasValue)
{
var result = WxWebApi.UploadImage(accessToken, request.File.ToByteArray());
if (result.ErrCode != 0)
{
resp.Error = new Error
{
ErrCode = result.ErrCode,
ErrMsg = result.ErrMsg
};
}
else
{
resp.ImageId = result.MediaId;
resp.Url = result.Url;
}
}
else
{
resp.Error = new Error
{
ErrCode = 99999,
ErrMsg = "AccessToken Missing"
};
}
return(Task.FromResult(resp));
}
public async Task ShouldUploadImageMultipartJson()
{
var client = _fixture.CreateClient();
if (File.Exists("Image2.png"))
{
File.Delete("Image2.png");
}
using var fs = File.OpenRead("cybtan.png");
var content = new MultipartFormDataContent("----WebKitFormBoundarymx2fSWqWSd0OxQq1");
var json = JsonConvert.SerializeObject(new { Size = fs.Length, Name = "Image2.png" });
content.Add(new StringContent(json, Encoding.UTF8, "application/json"), "content");
content.Add(new StreamContent(fs, (int)fs.Length), "Image", "Image.png");
var response = await client.PostAsync("/api/order/upload", content);
Assert.NotNull(response);
Assert.True(response.IsSuccessStatusCode);
var bytes = await response.Content.ReadAsByteArrayAsync();
UploadImageResponse obj = BinaryConvert.Deserialize <UploadImageResponse>(bytes);
fs.Seek(0, SeekOrigin.Begin);
var hash = CryptoService.ToStringX2(new SymetricCryptoService().ComputeHash(fs));
Assert.Equal(hash, obj.M5checksum);
}
public async Task ShouldUploadImage()
{
if (File.Exists("Image.png"))
{
File.Delete("Image.png");
}
using var fs = File.OpenRead("cybtan.png");
UploadImageResponse result = await _service.UploadImage(new UploadImageRequest
{
Size = (int)fs.Length,
Name = "Image.png",
Image = fs
});
Assert.NotNull(result);
Assert.NotNull(result.Url);
Assert.True(File.Exists("Image.png"));
fs.Seek(0, SeekOrigin.Begin);
var hash = CryptoService.ToStringX2(new SymetricCryptoService().ComputeHash(fs));
Assert.Equal(hash, result.M5checksum);
}
public static UploadImageResponse ToModel(this ImageWriterResponse response)
{
UploadImageResponse uploadImageResponse = new UploadImageResponse()
{
ImageUrl = response.Response
};
return(uploadImageResponse);
}
public async Task DeleteNonExistingImage()
{
var uploadImageResponse = new UploadImageResponse
{
ImageId = GenerateRandomID()
};
var e = await Assert.ThrowsAsync <ImageServiceException>(() => _imageServiceClient.DeleteImage(uploadImageResponse.ImageId));
Assert.Equal(HttpStatusCode.NotFound, e.StatusCode);
}
public async Task <IActionResult> UploadImage()
{
UploadImageRequestValidator validator = new UploadImageRequestValidator();
validator.EnsureValidity(Request);
UploadImageResponse response = await _imageService.UploadImageAsync(Request.ToEntity());
return(response.ToUser());
}
public static UploadImageResponse Unmarshall(UnmarshallerContext context)
{
UploadImageResponse uploadImageResponse = new UploadImageResponse();
uploadImageResponse.HttpResponse = context.HttpResponse;
uploadImageResponse.Code = context.StringValue("UploadImage.Code");
uploadImageResponse.Message = context.StringValue("UploadImage.Message");
uploadImageResponse.RequestId = context.StringValue("UploadImage.RequestId");
uploadImageResponse.Data = context.StringValue("UploadImage.Data");
return(uploadImageResponse);
}
public async Task <ActionResult> AddPost(ViewModels.Wall.Form form, IFormFile mediaFile)
{
if (ModelState.IsValid)
{
MediaId mediaId = null;
if (mediaFile != null)
{
using (var mediaStream = mediaFile.OpenReadStream())
{
var memoryStream = new MemoryStream();
mediaStream.CopyTo(memoryStream);
UploadImageResponse uploadResponse = await clientProvider.MediaClient.UploadImageAsync(new UploadImageRequest
{
Image = new Image
{
Data = ByteString.CopyFrom(memoryStream.ToArray()),
Mimetype = mediaFile.ContentType
}
});
mediaId = uploadResponse.Id;
}
}
await clientProvider.WallClient.PostToWallAsync(new PostToWallRequest
{
Post = new WallPost
{
Username = Constants.DemoUsername,
Caption = form.Caption,
MediaId = mediaId
}
});
return(RedirectToAction("Index"));
}
return(ViewForm());
}
private async Task UploadAchievementImage(string filename, Stream image)
{
this.SetUpMockAuth();
int fileSize = (int)image.Length;
Guid xfusId = Guid.NewGuid();
string xfusToken = "1234";
Uri initUri = new Uri(new Uri(ClientSettings.Singleton.XAchEndpoint), "/assets/initialize");
XachInitializeResponse initResponse = new XachInitializeResponse()
{
XfusId = xfusId,
XfusToken = xfusToken,
XfusUploadWindowLocation = "5678"
};
SetMetadataResponse setMetadataResponse = new SetMetadataResponse()
{
BlobPartitions = 1,
ChunkList = new int[] { 1 },
ChunkSize = fileSize,
Error = false,
Id = xfusId,
Message = string.Empty,
ResumeRestart = false,
ServerLocation = string.Empty
};
UploadImageResponse uploadResponse = new UploadImageResponse()
{
AbsoluteUri = string.Empty,
ChunkNum = 1,
Error = false,
ErrorCode = 0,
Location = string.Empty,
Message = string.Empty,
MissingChunks = null,
RawLocation = string.Empty,
State = string.Empty
};
AchievementImage finalizeResponse = new AchievementImage()
{
AssetId = Guid.NewGuid(),
CdnUrl = new Uri("https://xboxlive.com/"),
HeightInPixels = 1080,
ImageType = "png",
IsPublic = true,
Scid = new Guid(DefaultScid),
ThumbnailCdnUrl = new Uri("https://xboxlive.com/"),
WidthInPixels = 1920
};
string expectedToken = this.ExpectedToken(DefaultScid, null);
this.mockHandler.Expect(initUri.ToString())
.WithHeaders("Authorization", expectedToken)
.Respond(res => this.ExpectedJsonResponse(initResponse));
Uri setMetadataUri = new Uri(new Uri(ClientSettings.Singleton.XFusEndpoint), $"/upload/SetMetadata?filename={filename}&fileSize={fileSize}&id={xfusId}&token={xfusToken}");
this.mockHandler.Expect(setMetadataUri.ToString())
.WithHeaders("Authorization", expectedToken)
.Respond(res => this.ExpectedJsonResponse(setMetadataResponse));
Uri uploadChunkUri = new Uri(new Uri(ClientSettings.Singleton.XFusEndpoint), $"/upload/uploadchunk/{xfusId}?blockNumber=1&token={xfusToken}");
this.mockHandler.Expect(uploadChunkUri.ToString())
.WithHeaders("Authorization", expectedToken)
.Respond(res => this.ExpectedJsonResponse(uploadResponse));
Uri finishUploadUri = new Uri(new Uri(ClientSettings.Singleton.XFusEndpoint), $"/upload/finished/{xfusId}?token={xfusToken}");
this.mockHandler.Expect(finishUploadUri.ToString())
.WithHeaders("Authorization", expectedToken)
.Respond(res => this.ExpectedJsonResponse(uploadResponse));
Uri finalizeUri = new Uri(new Uri(ClientSettings.Singleton.XAchEndpoint), $"/scids/{DefaultScid}/images");
this.mockHandler.Expect(finalizeUri.ToString())
.WithHeaders("Authorization", expectedToken)
.Respond(res => this.ExpectedJsonResponse(finalizeResponse));
ConfigResponse <AchievementImage> response = await ConfigurationManager.UploadAchievementImageAsync(new Guid(DefaultScid), filename, image);
Assert.AreEqual(finalizeResponse.AssetId, response.Result.AssetId);
}
/// <summary>
/// Converts the server response into Json object as per the API Contract.
/// </summary>
/// <param name="response"></param>
/// <returns></returns>
public static IActionResult ToUser(this UploadImageResponse response)
{
return(new OkObjectResult(response));
}
