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 <string> UploadDPAsync(string base64)
{
string Id = string.Empty;
string url = string.Empty;
byte[] myFileContent;
try
{
UploadImageRequest uploadImageRequest = new UploadImageRequest();
uploadImageRequest.ImageInfo = new FileMeta();
uploadImageRequest.IsAsync = false;
string base64Norm = base64.Replace("data:image/png;base64,", "");
myFileContent = System.Convert.FromBase64String(base64Norm);
uploadImageRequest.ImageByte = myFileContent;
uploadImageRequest.ImageInfo.FileType = "jpg";
uploadImageRequest.ImageInfo.FileName = String.Format("dp_{0}.{1}", ViewBag.UId, uploadImageRequest.ImageInfo.FileType);
uploadImageRequest.ImageInfo.Length = uploadImageRequest.ImageByte.Length;
Id = this.ServiceClient.Post <string>(uploadImageRequest);
if (ViewBag.cid == "expressbase")
{
url = string.Format("http://localhost:5000/static/dp/dp_{0}.jpg", ViewBag.UId);
}
else
{
url = string.Format("http://{0}.localhost:5000/static/dp_{1}.{2}", ViewBag.cid, ViewBag.UId, uploadImageRequest.ImageInfo.FileType);
}
}
catch (Exception e)
{
return("upload failed");
}
return(url);
}
public async Task <UserProfileResponse> SetProfilePicture(UploadImageRequest req, int userId)
{
var profileModel = await _dbContext.UserProfiles.Include(prof => prof.User).Where(x => x.User.Id == userId).FirstOrDefaultAsync();
if (profileModel == null)
{
var errorResp = new UserProfileResponse {
Succes = false, Errors = new List <string>()
};
errorResp.Errors.Add("User with such id does not exist!");
return(errorResp);
}
var newAvatarName = await _imageService.UploadImage(Enums.ImageTypeEnum.PROFILE_PICTURE, req);
if (profileModel.ProfilePicturePath != "\\images\\avatars\\default.png")
{
_imageService.DeleteImage(profileModel.ProfilePicturePath);
}
profileModel.ProfilePicturePath = newAvatarName;
_dbContext.Update(profileModel);
_dbContext.SaveChanges();
var response = _mapper.Map <UserProfileResponse>(profileModel);
return(response);
}
/// <summary>
/// Takes an UploadImageRequest type object and tries to save the image in it
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <UploadImageResponse> UploadImageAsync(UploadImageRequest request)
{
IFormFile file = request.File;
ImageWriterResponse response = await _imageWriter.WriteFile(file);
return(response.ToModel());
}
public async Task <UploadImageResponse> UploadImage(UploadImageRequest request)
{
if (request.Image == null)
{
throw new ValidationException().AddError("Image", "Image is required");
}
using (var fs = new FileStream(request.Name, FileMode.Create, FileAccess.Write))
{
await request.Image.CopyToAsync(fs);
await fs.FlushAsync();
}
request.Image.Position = 0;
var hash = await Task.Run(() => new SymetricCryptoService().ComputeHash(request.Image));
var checkSum = CryptoService.ToStringX2(hash);
return(new UploadImageResponse
{
Url = "http://localhost/image.jpg",
M5checksum = checkSum
});
}
public IActionResult UploadImage(UploadImageRequest uploadRequest)
{
if (uploadRequest.FormFile == null)
{
return(BadRequest("Image is bad format or null"));
}
using (var stream = uploadRequest.FormFile.OpenReadStream())
{
var image = new byte[stream.Length];
stream.Read(image, 0, (int)stream.Length);
var picture = new Picture()
{
Image = image
};
var location = _imageService.ExtractLocationFromImage(picture);
if (!double.IsNaN(location.Item1) || !double.IsNaN(location.Item2))
{
uploadRequest.Latitude = location.Item1;
uploadRequest.Longitude = location.Item2;
}
stream.Read(image, 0, (int)stream.Length);
_teamService.UploadImage(uploadRequest.GameId, uploadRequest.TeamId, uploadRequest.Latitude, uploadRequest.Longitude, image, uploadRequest.ImageName);
return(Ok());
}
}
public async Task <IActionResult> UploadImage([FromForm] UploadImageRequest request)
{
if (request.Name == null)
{
return(ControllerResultWithToast.FailureWithResourceMesg("NameNotSet", this));
}
if (request.Description == null)
{
return(ControllerResultWithToast.FailureWithResourceMesg("DescriptionNotSet", this));
}
if (request.Source == null)
{
return(ControllerResultWithToast.FailureWithResourceMesg("SourceNotSet", this));
}
if (request.File == null)
{
return(ControllerResultWithToast.FailureWithResourceMesg("FileNotSet", this));
}
var userId = await UserServices.UserIdFromContextAsync(HttpContext, userManager);
using var stream = request.File.OpenReadStream();
using var reader = new BinaryReader(stream);
var fileContent = reader.ReadBytes((int)request.File.Length);
var applicationRequest = new StoreImage.Request(userId, request.Name.Trim(), request.Description.Trim(), request.Source.Trim(), request.File.ContentType, fileContent);
await new StoreImage(callContext).RunAsync(applicationRequest);
return(ControllerResultWithToast.Success($"{Get("ImageSavedWithName")} '{applicationRequest.Name.Trim()}'", this));
}
public Task <String> UploadImage(ImageTypeEnum type, UploadImageRequest req)
{
var newfileName = RandomName() + Path.GetExtension(req.Image.FileName);
var path = GetPath(type, newfileName);
var imagePath = UploadImageToServer(req.Image, path);
return(Task.FromResult(GetRelativePath(type, newfileName)));
}
public static UploadImageRequest ToEntity(this Microsoft.AspNetCore.Http.HttpRequest httpRequest)//(this IFormFile file)
{
IFormFile file = httpRequest.Form.Files[0];
var request = new UploadImageRequest()
{
File = file
};
return(request);
}
public Response UploadImage(UploadImageRequest request)
{
var filePath = Path.Combine("images", request.ImageUrl.FileName);
if (request.ImageUrl.Length > 0)
{
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
request.ImageUrl.CopyTo(fileStream);
}
}
return(new UploadImageResponseOK(filePath, request.ImageUrl.FileName));
}
public override Task <UploadImageReply> UploadImage(UploadImageRequest request, ServerCallContext context)
{
Console.WriteLine("Called upload image method");
var data = Convert.FromBase64String(request.Image);
File.WriteAllBytes("../../../fromClient.jpg", data);
return(Task.FromResult(new UploadImageReply
{
Result = "Success"
}));
}
/// <summary>
/// Upload image from the stream.
/// </summary>
/// <param name="request">The upload image request.</param>
/// <returns>The upload image response.</returns>
public UploadImageResponse Post(UploadImageRequest request)
{
MediaFolder parentFolder = null;
if (request.Data.FolderId.HasValue)
{
parentFolder = repository.AsQueryable <MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.FirstOne();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.Image)
{
throw new CmsApiValidationException("Folder must be type of an image.");
}
}
var maxLength = configuration.Storage.MaximumFileNameLength > 0 ? configuration.Storage.MaximumFileNameLength : 100;
// Fix for IIS express + IE (if full path is returned)
var fileName = Path.GetFileName(request.Data.FileName);
if (fileName.Length > maxLength)
{
fileName = string.Concat(Path.GetFileNameWithoutExtension(fileName.Substring(0, maxLength)), Path.GetExtension(fileName));
}
var mediaImage = new MediaImage
{
Id = request.Data.Id.GetValueOrDefault(),
Type = Module.MediaManager.Models.MediaType.Image,
Caption = request.Data.Caption,
Title = request.Data.Title ?? fileName,
Description = request.Data.Description,
Size = request.Data.FileStream.Length,
Folder = parentFolder,
OriginalFileName = fileName,
OriginalFileExtension = Path.GetExtension(fileName)
};
var savedImage = mediaImageService.UploadImageWithStream(request.Data.FileStream, mediaImage, request.Data.WaitForUploadResult);
if (savedImage != null)
{
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(savedImage);
}
return(new UploadImageResponse
{
Data = savedImage.Id,
});
}
public UploadAsyncResponse Post(UploadImageAsyncRequest request)
{
UploadAsyncResponse res = new UploadAsyncResponse();
Log.Info("Inside ImageAsyncUpload");
IUploadImageRequest req = null;
if (request.ImageInfo.FileCategory == EbFileCategory.Dp)
{
req = new UploadDpRequest();
}
else if (request.ImageInfo.FileCategory == EbFileCategory.Images)
{
req = new UploadImageRequest();
}
else if (request.ImageInfo.FileCategory == EbFileCategory.SolLogo)
{
req = new UploadLogoRequest();
}
else if (request.ImageInfo.FileCategory == EbFileCategory.LocationFile)
{
req = new UploadLocRequest();
}
try
{
string context = string.IsNullOrEmpty(request.ImageInfo.Context) ? StaticFileConstants.CONTEXT_DEFAULT : request.ImageInfo.Context;
req.Byte = request.ImageByte;
req.FileCategory = request.ImageInfo.FileCategory;
req.SolutionId = request.SolutionId;
req.SolnId = request.SolnId;
req.UserId = (req is UploadDpRequest) ? request.UserIntId : request.UserId;
req.UserAuthId = request.UserAuthId;
req.BToken = (!String.IsNullOrEmpty(this.Request.Authorization)) ? this.Request.Authorization.Replace("Bearer", string.Empty).Trim() : String.Empty;
req.RToken = (!String.IsNullOrEmpty(this.Request.Headers["rToken"])) ? this.Request.Headers["rToken"] : String.Empty;
req.SubscriptionId = (!String.IsNullOrEmpty(this.Request.Headers[TokenConstants.SSE_SUBSCRIP_ID])) ? this.Request.Headers[TokenConstants.SSE_SUBSCRIP_ID] : String.Empty;
req.ImageRefId = GetFileRefId(request.UserId, request.ImageInfo.FileName, request.ImageInfo.FileType, request.ImageInfo.MetaDataDictionary.ToJson(), request.ImageInfo.FileCategory, request.ImageInfo.Context);
this.MessageProducer3.Publish(req);
res.FileRefId = req.ImageRefId;
}
catch (Exception e)
{
Log.Info("Exception:" + e.ToString());
res.FileRefId = 0;
res.ResponseStatus.Message = e.Message;
}
return(res);
}
public void ToDictionary_Works()
{
var request = new UploadImageRequest()
{
ImageSignature = new byte[] { 1, 2, 3, 4 },
ImageSize = 4,
ImageType = "Developer",
}.ToDictionary();
Assert.Equal("ReceiveBytes", Assert.Contains("Command", request).ToObject());
Assert.Equal(new byte[] { 1, 2, 3, 4 }, Assert.Contains("ImageSignature", request).ToObject());
Assert.Equal(4, Assert.Contains("ImageSize", request).ToObject());
Assert.Equal("Developer", Assert.Contains("ImageType", request).ToString());
}
public ActionResult Upload(TestUploadViewModel model)
{
if (model != null && model.File != null)
{
using (var api = ApiFactory.Create())
{
if (model.Type == "file")
{
var uploadRequest = new UploadFileRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Files.Upload.Post(uploadRequest);
var getRequest = new GetFileRequest {
FileId = uploadResponse.Data.Value
};
var getResponse = api.Media.File.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>File upload successful!</h2> File can be downloaded here: <div><a href='{0}' />{1}</a></div>",
getResponse.Data.FileUrl,
getResponse.Data.Title);
}
else
{
var uploadRequest = new UploadImageRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Images.Upload.Post(uploadRequest);
var getRequest = new GetImageRequest {
ImageId = uploadResponse.Data.Value
};
var getResponse = api.Media.Image.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>Image upload successful!</h2> <div><img src='{0}' alt='{1}' /></div>",
getResponse.Data.ImageUrl,
getResponse.Data.Title);
}
}
}
return(View(model));
}
private async Task <string> Upload(UploadImageRequest model)
{
Account ac = new(model.Cloud, model.ApiKey, model.Secret);
Cloudinary c = new(ac);
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(model.ImageName, model.Image),
Folder = "RoutineApp",
};
var uploadResult = await c.UploadAsync(uploadParams);
return(uploadResult.SecureUrl.ToString());
}
public async Task <NodeResponse> UploadImage(UploadImageRequest uploadImageRequest)
{
using (var content = new MultipartFormDataContent())
{
content.Add(new StringContent(uploadImageRequest.GameId.ToString()), "gameId");
content.Add(new StringContent(uploadImageRequest.TeamId.ToString()), "teamId");
content.Add(new StringContent(uploadImageRequest.Latitude.ToString()), "latitude");
content.Add(new StringContent(uploadImageRequest.Longitude.ToString()), "longitude");
using (var fileStream = uploadImageRequest.FormFile.OpenReadStream())
{
content.Add(new StreamContent(fileStream), "formFile", "image.jpg");
return(await PostAsync <NodeResponse>($"{_httpClient.BaseAddress}api/Team/UploadImage/", content));
}
}
}
/// <summary>
/// 本接口 ( UploadImage ) 用于证件图片上传 。
/// </summary>
/// <param name="req"><see cref="UploadImageRequest"/></param>
/// <returns><see cref="UploadImageResponse"/></returns>
public UploadImageResponse UploadImageSync(UploadImageRequest req)
{
JsonResponseModel <UploadImageResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "UploadImage");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <UploadImageResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
/// <summary>
/// Upload image from the stream.
/// </summary>
/// <param name="request">The upload image request.</param>
/// <returns>The upload image response.</returns>
public UploadImageResponse Post(UploadImageRequest request)
{
MediaFolder parentFolder = null;
if (request.Data.FolderId.HasValue)
{
parentFolder = repository.AsQueryable<MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.FirstOne();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.Image)
{
throw new CmsApiValidationException("Folder must be type of an image.");
}
}
var maxLength = configuration.Storage.MaximumFileNameLength > 0 ? configuration.Storage.MaximumFileNameLength : 100;
// Fix for IIS express + IE (if full path is returned)
var fileName = Path.GetFileName(request.Data.FileName);
if (fileName.Length > maxLength)
{
fileName = string.Concat(Path.GetFileNameWithoutExtension(fileName.Substring(0, maxLength)), Path.GetExtension(fileName));
}
var mediaImage = new MediaImage
{
Id = request.Data.Id.GetValueOrDefault(),
Type = Module.MediaManager.Models.MediaType.Image,
Caption = request.Data.Caption,
Title = request.Data.Title ?? fileName,
Description = request.Data.Description,
Size = request.Data.FileStream.Length,
Folder = parentFolder,
OriginalFileName = fileName,
OriginalFileExtension = Path.GetExtension(fileName)
};
var savedImage = mediaImageService.UploadImageWithStream(request.Data.FileStream, mediaImage, request.Data.WaitForUploadResult);
if (savedImage != null)
{
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(savedImage);
}
return new UploadImageResponse
{
Data = savedImage.Id,
};
}
public async Task <IActionResult> UploadImage([FromForm] UploadImageRequest request)
{
if (request.Name == null)
{
return(BadRequest(UploadImageResultViewModel.Failure(localizer["NameNotSet"].Value, false, localizer)));
}
if (request.Description == null)
{
return(BadRequest(UploadImageResultViewModel.Failure(localizer["DescriptionNotSet"].Value, false, localizer)));
}
if (request.Source == null)
{
return(BadRequest(UploadImageResultViewModel.Failure(localizer["SourceNotSet"].Value, false, localizer)));
}
if (request.File == null)
{
return(BadRequest(UploadImageResultViewModel.Failure(localizer["FileNotSet"].Value, false, localizer)));
}
try
{
var user = await userManager.GetUserAsync(HttpContext.User);
if (user == null)
{
return(BadRequest(UploadImageResultViewModel.Failure(localizer["NeedLogin"].Value, false, localizer)));
}
using (var stream = request.File.OpenReadStream())
using (var reader = new BinaryReader(stream))
{
var fileContent = reader.ReadBytes((int)request.File.Length);
var applicationRequest = new StoreImage.Request(user, request.Name, request.Description, request.Source, request.File.ContentType, fileContent);
var id = await new StoreImage(dbContext, localizer).RunAsync(applicationRequest);
if (id == Guid.Empty)
{
throw new ApplicationException("Stored image with empty GUID as id");
}
return(Ok(UploadImageResultViewModel.Success(localizer["ImageSavedWithName"].Value + $" '{applicationRequest.Name}'", localizer)));
}
}
catch (Exception e)
{
return(ControllerError.BadRequest(e, this));
}
}
public void UploadImageWithTitle()
{
// Arrange
var formFile = A.Fake <IFormFile>();
var uploadImageRequest = new UploadImageRequest()
{
FormFile = formFile, GameId = 1, TeamId = 1, Longitude = 15, Latitude = 15, ImageName = "3"
};
// Act
var result = _target.UploadImage(uploadImageRequest);
// Assert
Check.That(result).InheritsFrom <IActionResult>();
A.CallTo(() => _teamService.UploadImage(uploadImageRequest.GameId, uploadImageRequest.TeamId, uploadImageRequest.Latitude, uploadImageRequest.Longitude, A <byte[]> ._, uploadImageRequest.ImageName))
.MustHaveHappened();
}
public void UploadImage()
{
// Arrange
var formFile = A.Fake <IFormFile>();
var uploadImageRequest = new UploadImageRequest()
{
FormFile = formFile, GameId = 1, TeamId = 1, Longitude = 15, Latitude = 15
};
// Act
var result = _target.UploadImage(uploadImageRequest);
// Assert
Check.That(result).InheritsFrom <IActionResult>();
A.CallTo(() => _teamService.UploadImage(A <int> ._, A <int> ._, A <double> ._, A <double> ._, A <byte[]> ._, A <string> ._))
.MustHaveHappened();
}
public JsonResult Upload([FromBody] UploadImageRequest requestData)
{
List <Task <string> > tasks = new List <Task <string> >();
foreach (string url in requestData.ImagesUrls)
{
tasks.Add(imageUploader.Upload(url));
}
Task <string[]> continuation = Task.WhenAll(tasks);
try
{
continuation.Wait();
}
catch (AggregateException) {}
List <string> failed = new List <string>();
Dictionary <string, UploadedImagesData> uploaded = new Dictionary <string, UploadedImagesData>();
for (int i = 0; i < tasks.Count; i++)
{
if (tasks[i].Status == TaskStatus.RanToCompletion)
{
string originalUrl = "/original/" + tasks[i].Result + ".jpg";
string previewUrl = "/preview/" + tasks[i].Result + ".jpg";
uploaded.Add(requestData.ImagesUrls[i], new UploadedImagesData
{
Original = originalUrl,
Preview = previewUrl
});
}
else
{
failed.Add(requestData.ImagesUrls[i]);
}
}
return(new JsonResult(new
{
Uploaded = uploaded,
Failed = failed
}));
}
/// <summary>
/// Upload image from the stream.
/// </summary>
/// <param name="request">The upload image request.</param>
/// <returns>The upload image response.</returns>
public UploadImageResponse Post(UploadImageRequest request)
{
IEnumerable <MediaFolder> parentFolderFuture = null;
if (request.Data.FolderId.HasValue)
{
parentFolderFuture = repository.AsQueryable <MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.ToFuture();
}
MediaFolder parentFolder = null;
if (parentFolderFuture != null)
{
parentFolder = parentFolderFuture.First();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.Image)
{
throw new CmsApiValidationException("Folder must be type of an image.");
}
}
var mediaImage = new MediaImage
{
Id = request.Data.Id.GetValueOrDefault(),
Type = Module.MediaManager.Models.MediaType.Image,
Caption = request.Data.Caption,
Title = request.Data.Title,
Description = request.Data.Description
};
var savedImage = mediaImageService.UploadImage(
parentFolder != null ? parentFolder.Id : Guid.Empty,
request.Data.FileName,
request.Data.FileStream.Length,
request.Data.FileStream,
Guid.Empty,
mediaImage);
return(new UploadImageResponse
{
Data = savedImage.Id
});
}
public ActionResult Upload(TestUploadViewModel model)
{
if (model != null && model.File != null)
{
using (var api = ApiFactory.Create())
{
if (model.Type == "file")
{
var uploadRequest = new UploadFileRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Files.Upload.Post(uploadRequest);
var getRequest = new GetFileRequest { FileId = uploadResponse.Data.Value };
var getResponse = api.Media.File.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>File upload successful!</h2> File can be downloaded here: <div><a href='{0}' />{1}</a></div>",
getResponse.Data.FileUrl,
getResponse.Data.Title);
}
else
{
var uploadRequest = new UploadImageRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Images.Upload.Post(uploadRequest);
var getRequest = new GetImageRequest { ImageId = uploadResponse.Data.Value };
var getResponse = api.Media.Image.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>Image upload successful!</h2> <div><img src='{0}' alt='{1}' /></div>",
getResponse.Data.ImageUrl,
getResponse.Data.Title);
}
}
}
return View(model);
}
public async Task UploadImage()
{
// Arrange
byte[] data = new byte[15];
FakeResponse("ImageHuntWebServiceClientTest.Data.StartTeamFirstNode.json");
using (var stream = new MemoryStream(Encoding.ASCII.GetBytes("toto")))
{
var uploadrequest = new UploadImageRequest()
{
FormFile = new FormFile(stream, 0, stream.Length, "formFile", "toto.txt")
};
var response = await _target.UploadImage(uploadrequest);
}
// Act
// Assert
//A.CallTo(() => _fakeHttpMessageHandler.(A<string>._, A<HttpContent>._, A<CancellationToken>._)).MustHaveHappened();
}
public Response UploadImage(UploadImageRequest request)
{
try
{
UploadImageResponse retval = new UploadImageResponseInvalidImageFile();
var imageUrl = _imageWriter.UploadImage(request.Image);
if (imageUrl.Result != "")
{
retval = new UploadImageResponseOK(imageUrl.Result);
_dal.UpdateImageUrl(request.DocId, imageUrl.Result);
}
return(retval);
}
catch (Exception ex)
{
return(new ResponseError(ex.Message));
}
}
public async Task <ActionResult <string> > UploadImage([FromBody] UploadImageRequest request)
{
try
{
var requestUid = await HttpContext.Request.AuthorizeWithFirebase();
if (requestUid == null)
{
return(Unauthorized());
}
return(Ok(await _googleCloudStorage.UploadFile(request)));
}
catch (Exception e)
{
_logger.LogError(e, "Error uploading file");
throw;
}
}
public async Task <IActionResult> Upload([FromForm] IFormFile file)
{
var request = new UploadImageRequest()
{
Image = file,
Username = User.Identity.Name
};
var response = await _images.UploadAsync(request);
if (!response.Success)
{
return(BadRequest(response.ErrorMessage));
}
var id = response.Result;
return(StatusCode(StatusCodes.Status201Created, new { UploadedImageId = id }));
}
public ServiceResult <IdentityResultCode> SetAvatar(UploadImageRequest request)
{
var photo = request.Files.FirstOrDefault();
if (photo == null || photo.Length == 0)
{
return(BuildResult(false, IdentityResultCode.SaveImageFailure, EmptyFileErrorMsg));
}
var uploadResult = _blobStorage.UploadPhoto(photo);
// Todo: update database
if (uploadResult.IsSuccess)
{
return(BuildResult(true, IdentityResultCode.Success, resultObj: uploadResult.JsonObj));
}
return(BuildResult(false, IdentityResultCode.SaveImageFailure, uploadResult.ErrorMessage));
}
public async Task <ImageInfo> MakeAnalysisRequestAsync(UploadImageRequest model)
{
var imageInfo = new ImageInfo();
try
{
HttpClient client = new HttpClient();
// Request headers.
client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", _computerVisionConfiguration.SubscriptionKey);
// Assemble the URI for the REST API Call.
var uri = string.Format("{0}?visualFeatures={1}", _computerVisionConfiguration.ApiUrl, string.Join(",", _requestParams));
HttpResponseMessage response;
using (var stream = new MemoryStream())
{
await model.Body.CopyToAsync(stream);
var fileContent = stream.ToArray();
using (ByteArrayContent content = new ByteArrayContent(fileContent))
{
// This example uses content type "application/octet-stream".
// The other content types you can use are "application/json"
// and "multipart/form-data".
content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
// Make the REST API call.
response = await client.PostAsync(uri, content);
}
}
if (response.IsSuccessStatusCode)
{
imageInfo = JsonConvert.DeserializeObject <ImageInfo>(await response.Content.ReadAsStringAsync());
}
}
catch (Exception e)
{
throw;
}
return(imageInfo);
}
public async Task <ActionResult <ImageInfo> > Post(UploadImageRequest uploadImageRequest)
{
if (!Uri.IsWellFormedUriString(uploadImageRequest.ImageUrl, UriKind.Absolute))
{
return(BadRequest(IncorrectUrlFormat));
}
_logger.LogDebug(DownloadingByUrl, uploadImageRequest.ImageUrl);
var imageStream = await _imageDownloadClient.GetMemoryStream(uploadImageRequest.ImageUrl);
if (imageStream == null)
{
return(BadRequestAndLog(string.Format(CouldNotDownloadImage, uploadImageRequest.ImageUrl)));
}
_logger.LogDebug(DownloadedByUrl, uploadImageRequest.ImageUrl);
return(await UploadImage(imageStream, uploadImageRequest.PartitionKey));
}
/// <summary>
/// Upload image from the stream.
/// </summary>
/// <param name="request">The upload image request.</param>
/// <returns>The upload image response.</returns>
public UploadImageResponse Post(UploadImageRequest request)
{
MediaFolder parentFolder = null;
if (request.Data.FolderId.HasValue)
{
parentFolder = repository.AsQueryable<MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.FirstOne();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.Image)
{
throw new CmsApiValidationException("Folder must be type of an image.");
}
}
var mediaImage = new MediaImage
{
Id = request.Data.Id.GetValueOrDefault(),
Type = Module.MediaManager.Models.MediaType.Image,
Caption = request.Data.Caption,
Title = request.Data.Title ?? Path.GetFileName(request.Data.FileName),
Description = request.Data.Description,
Size = request.Data.FileStream.Length,
Folder = parentFolder,
OriginalFileName = request.Data.FileName,
OriginalFileExtension = Path.GetExtension(request.Data.FileName)
};
var savedImage = mediaImageService.UploadImageWithStream(request.Data.FileStream, mediaImage, request.Data.WaitForUploadResult);
if (savedImage != null)
{
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(savedImage);
}
return new UploadImageResponse
{
Data = savedImage.Id,
};
}