public APIResponse <string> UpdateImageData(ImageUploadRequest model)
{
using (ApplicationDbContext db = new ApplicationDbContext())
{
try
{
string query = string.Empty;
using (HttpClient client = new HttpClient())
{
string url = "https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/8e983fbd-0438-4bd2-9161-8c8cbf81f82e?subscription-key=4e80642610f8481b914a81a0920c8073&verbose=true&timezoneOffset=0&q=want%20to%20jump%20on%20a%20trampoline";
HttpResponseMessage responseData = client.GetAsync(url).Result;
string resultprofile = responseData.Content.ReadAsStringAsync().Result;
ImageDataProcessing dataQuery = JsonConvert.DeserializeObject <ImageDataProcessing>(resultprofile);
query = dataQuery.query;
}
var entity = new ImageDataEntity {
ImageName = model.imageName,
Query = query,
DataResponse = JsonConvert.SerializeObject(model.rootObject),
Image = model.imageByte,
DateAdded = DateTime.Now,
IsLive = true
};
db.ImageData.Add(entity);
db.SaveChanges();
foreach (var q in model.tag)
{
db.ImageTag.Add(new ImageTagEntity()
{
ImageId = entity.Id,
Name = q,
DateAdded = DateTime.Now,
IsLive = true
});
}
db.SaveChanges();
return(new APIResponse <string>
{
Data = "Success",
Succeeded = true
});
}
catch (Exception ex)
{
return(new APIResponse <string>
{
Data = ex.Message,
Succeeded = false
});
}
}
}
public IActionResult AvatarUploadAsync([FromBody] ImageUploadRequest request)
{
if (request.Base64Image == null || !(request.Base64Image.Length > 0))
{
return(BadRequest("Missing base64 encoded image string."));
}
try
{
string clientIdentifier = User.FindFirst(ClaimTypes.NameIdentifier).Value;
string Filename = GenerateFileName(clientIdentifier, request);
string UploadsDir = Path.Combine(appEnv.WebRootPath, "users/avatars");
string WritePath = Path.Combine(UploadsDir, Filename); // Pripremi path i ime slike
byte[] imageBytes = Convert.FromBase64String(request.Base64Image);
System.IO.File.WriteAllBytes(WritePath, imageBytes);
string imgUploadedTo = "https://localhost:44380/users/avatars/" + Filename;
// save the url
accountSignalRClient.AvatarUpload(clientIdentifier, imgUploadedTo);
return(NoContent());
}
catch (Exception e)
{
// handle ili samo pusti da akcija vrati bad request?
return(BadRequest("Dogodila se greska pri konverziji base64 u sliku."));
}
}
public async Task <IActionResult> Post([FromBody] ImageUploadRequest request)
{
if (request is null)
{
return(BadRequest("Body is missing"));
}
switch (request.Type)
{
case ImageUploadType.ByUrls:
{
if (request.Urls is null)
{
return(BadRequest("Urls are missing"));
}
return(await UploadByUrls(request.Urls));
}
case ImageUploadType.ByBase64:
{
if (request.EncodedImages is null)
{
return(BadRequest("EncodedImages are missing"));
}
return(UploadByEncodedImages(request.EncodedImages));
}
default:
throw new NotImplementedException();
}
}
public async Task <bool> AddImageToSalelisting(ImageUploadRequest viewmodel)
{
string uri = string.Format("addImage");
var image = await client.GetResponseObject <ImageUploadRequest, bool>(uri, eHttpMethodType.POST, viewmodel);
return(image);
}
public async Task <IActionResult> AddPicture([FromBody] ImageUploadRequest request,
CancellationToken cancellationToken)
{
var command = new UpdateUserPictureCommand(_currentUserId, request.Data);
var result = await _mediator.Send(command, cancellationToken);
return(result.IsSuccess
? Ok(result.Data)
: result.ReturnErrorResponse());
}
public async Task <IActionResult> Upload(
[FromForm] ImageUploadRequest request,
CancellationToken cancellationToken)
{
var response = await _imageService.Upload(new UploadImage.Request
{
Image = request.Image
}, cancellationToken);
return(Created($"api/images/{response.Id}", new { response.Id }));
}
public IHttpActionResult AddImageSaleListing([FromBody] ImageUploadRequest viewmodel)
{
if (ModelState.IsValid)
{
if (_salelistingService.AddImageSaleListing(viewmodel.SaleListing, viewmodel.Image))
{
return(CreatedAtRoute("GetSaleListingByID", new { controller = "SaleListing", id = viewmodel.SaleListing.ID }, viewmodel.SaleListing));
}
return(NotFound());
}
return(BadRequest(ModelState));
}
public HttpResponseMessage UpdateImageRequest(ImageUploadRequest model)
{
IUserData _repository = new UserData();
var result = _repository.UpdateImageData(model);
if (result.Succeeded == true)
{
return(Request.CreateResponse(HttpStatusCode.OK, "Success"));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "error occured"));
}
}
public HttpResponseMessage Upload(ImageUploadRequest imageUploadRequest)
{
try
{
if (ModelState.IsValid)
{
var xmlDocumentName = Guid.NewGuid().ToString() + ".xml";
var imageUploadSession = new ImageUploadSession()
{
RequestNumber = imageUploadRequest.RequestNumber,
UserName = imageUploadRequest.UserName,
Image = new Image()
{
FileName = imageUploadRequest.ImageName,
SignedImageFileName = xmlDocumentName
}
};
var digitalCertificate = _digitalCertificateRepository.Query().FirstOrDefault();
ImageCryptographyManager.SignImage(
imageUploadRequest.ImageData,
//File.ReadAllBytes(HttpContext.Current.Server.MapPath("~/") + "\\" + "Test.png"),
digitalCertificate.PrivateKey,
Path.Combine(FilePaths.XMLBasePath, xmlDocumentName)
);
_imageUploadSessionRepository.Add(imageUploadSession);
return(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(LanguageConstants.ImageSuccessfullyUploaded)
});
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch
{
// If an uncaught exception occurs, return an error response
// with status code 500 (Internal Server Error)
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, LanguageConstants.InternalServerError));
}
}
public async Task <ActionResult> Index(HttpPostedFileBase Image)
{
var extension = Path.GetExtension(Image.FileName);
var response = await MakeAnalysisRequest(Image);
//var parsedResponse = JsonPrettyPrint(response);
var parsedResponse = FromJSON <ImageUploadObject>(response);
var tags = parsedResponse.tags.Where(x => x.confidence > 0.90).Select(x => x.name).ToList();
var rootData = JsonConvert.DeserializeObject <ImageUploadObject>(response);
ImageUploadRequest uploadData = new ImageUploadRequest();
uploadData.rootObject = rootData;
uploadData.imageName = DateTime.Now.ToString("yyyyMMddHHmmss") + "." + extension;
uploadData.tag = tags;
HttpPostedFileBase file = Request.Files[0] as HttpPostedFileBase;
file.InputStream.Position = 0;
int fileSizeInBytes = file.ContentLength;
MemoryStream target = new MemoryStream();
file.InputStream.CopyTo(target);
byte[] data = target.ToArray();
uploadData.imageByte = data;
string serializedData = JsonConvert.SerializeObject(uploadData);
HttpResponseMessage responseData = PostJsonRequest("http://localhost:6364/api/v1/admin/updateuserimage", serializedData, null);
string resultprofile = responseData.Content.ReadAsStringAsync().Result;
if (responseData.StatusCode == HttpStatusCode.OK)
{
return(Json(tags, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(null, JsonRequestBehavior.AllowGet));
}
// return Content(JsonPrettyPrint(response));
// return Json(tags, JsonRequestBehavior.AllowGet);
// return View();
//postedFile.InputStream
}
public async Task <IActionResult> AddImageToStorage(ImageUploadRequest imageUploadRequest)
{
var imageData = Convert.FromBase64String(imageUploadRequest.Content);
var storageAccount = CloudStorageAccount.Parse
(this.storageConnectionString);
blobClient = storageAccount.CreateCloudBlobClient();
blobContainer = blobClient.GetContainerReference(blobContainerName);
await blobContainer.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
CloudBlockBlob blob = blobContainer.GetBlockBlobReference("storage/fileName");
await blob.UploadFromByteArrayAsync(imageData, 0, imageData.Length);
return(File(imageData, "image/jpeg"));
}
public void UploadImageinformationTest()
{
var vehicle = new ImageInformationDto();
var large = "https://cvis.iaai.com/thumbnail?imageKeys=18693774~SID~I1";
vehicle.StockNumber = "18693774";
vehicle.FileName = "18693774_1";
vehicle.ImageByteArray = new WebClient().DownloadData(large);
var request = new ImageUploadRequest()
{
UserRequestInfo = User, ImageInformation = vehicle
};
var uploadStockImage = ImageClient.UploadImageInformation(request);
Assert.IsTrue(uploadStockImage.WasSuccessful);
}
public async Task <ActionResult <ImageUploadResult> > PostImage([FromForm] ImageUploadRequest imageUploadRequest)
{
if ((imageUploadRequest is null) || (imageUploadRequest.Files is null))
{
return(NotFound("No files provided"));
}
var files = imageUploadRequest.Files;
long maxId = _context.Images
.OrderByDescending(p => p.ImageId)
.Select(p => p.ImageId)
.FirstOrDefault();
var root = Directory.GetCurrentDirectory();
var cmsPath = Path.Combine(root, "cms");
Directory.CreateDirectory(cmsPath);
var result = new ImageUploadResult();
for (int i = 0; i < files.Length; i++)
{
string fileName = (maxId + 1 + i).ToString();
string filePath = Path.Combine(cmsPath, fileName);
using var stream = files[i].OpenReadStream();
using var fileStream = System.IO.File.OpenWrite(filePath);
await stream.CopyToAsync(fileStream).ConfigureAwait(true);
var image = new Image
{
PostId = 1,
ImagePath = filePath,
MimeType = files[i].ContentType
};
_context.Images.Add(image);
await _context.SaveChangesAsync().ConfigureAwait(true);
result.Ids.Add(fileName);
}
return(Ok(result));
}
public async Task <IActionResult> upload([FromBody] ImageUploadRequest request)
{
ImageUploadResponse cr = new ImageUploadResponse();
try
{
if (!ModelState.IsValid)
{
return(BadRequest(Commons.Helpers.Utility.GetResponse(ModelState)));
}
_logger.LogInformation($"request ID:{request.requestId} {Environment.NewLine} User ID:{request.userName}");
cr = await _orclRepo.UploadImage(request);
}
catch (Exception ex)
{
_logger.LogError($"request ID:{request.requestId} User ID:{request.userName}:- {Environment.NewLine} {ex.ToString()}");
return(StatusCode((int)HttpStatusCode.InternalServerError, Commons.Helpers.Utility.GetResponse(ex)));
}
return(CreatedAtAction("upload", cr));
}
/// <summary>
/// 上传图片
/// </summary>
/// <param name="contents"></param>
/// <returns></returns>
public string UploadImg(byte[] contents)
{
var result = "";
try
{
using (var client = new Tuhu.Service.Utility.FileUploadClient())
{
ImageUploadRequest image = new ImageUploadRequest($"activity/image/{DateTime.Now.ToString("yyyyMMdd")}/", contents);
var serviceResult = client.UploadImage(image);
if (serviceResult.Success)
{
return(serviceResult.Result);
}
}
}
catch (Exception ex)
{
Logger.Error("UploadImg", ex);
result = "";
}
return(result);
}
public async Task <ActionResult <ImageUploadResponse> > AddPicture(long audioId, [FromBody] ImageUploadRequest request,
CancellationToken cancellationToken)
{
var command = new UpdateAudioPictureCommand(audioId, request.Data);
var result = await _mediator.Send(command, cancellationToken);
return(result.IsSuccess
? Ok(result.Data)
: result.ReturnErrorResponse());
}
private static string GenerateFileName(string userIdentifier, ImageUploadRequest request)
{
// Example: 387615005051852_filename_9512.jpeg
return(userIdentifier + "_" + request.FileName + "_" +
Guid.NewGuid().ToString().Substring(0, 4) + "." + request.FileExtension);
}
//run every 10 minutes
public bool PushImageData()
{
bool successWhilePushing = true;
try
{
clsLog.LogInfo("PushImageData - Getting StockImage URLs to push");
var connection = ConfigurationManager.ConnectionStrings["Connection"].ConnectionString;
DataTable dt = new DataTable();
using (SqlConnection con = new SqlConnection(connection))
using (SqlCommand cmd = new SqlCommand("dyndata.dbo.SP_PUSHIMAGEDATA", con))
{
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
cmd.CommandType = CommandType.StoredProcedure;
da.Fill(dt);
}
}
var stocks = dt.Rows.OfType <DataRow>().ToList().ConvertAll(c => new Stock()
{
ImageIndex = Convert.ToInt16(c["imageindex"]), ImageURL = c["ImageUrl"].ToString().Trim(), StockNumber = c["stocknumber"].ToString().Trim()
});
var stack = new ConcurrentStack <Stock>(stocks);
clsLog.LogInfo("PushImageData - Got StockImage URLs to push");
Parallel.ForEach(stack, new ParallelOptions()
{
MaxDegreeOfParallelism = 10
}, p =>
//stocks.ForEach(p =>
{
clsLog.LogInfo("PushImageData - Sending Stock Image URLs " + p.StockNumber);
var imageinfo = new ImageInformationDto()
{
StockNumber = p.StockNumber,
FileName = p.StockNumber + "_" + p.ImageIndex,
ImageByteArray = GetImageBytes(p.ImageURL)
};
try
{
var request = new ImageUploadRequest()
{
UserRequestInfo = User, ImageInformation = imageinfo
};
var response = ImageClient.UploadImageInformation(request);
if (response.WasSuccessful)
{
clsLog.LogInfo("PushImageData - Sent Stock Image URLs " + p.StockNumber + "_" + p.ImageIndex);
p.Pushed = true;
File.Delete(p.ImageURL);
}
else
{
clsLog.LogInfo("PushImageData - Unable to send Stock Image URLs " + p.StockNumber + "_" + p.ImageIndex);
}
}
catch (Exception ex1)
{
clsLog.LogError("PushImageData - Error while sending HighRes stock Image urls. Stock" + p.StockNumber + "_" + p.ImageIndex + " Error " + ex1.Message);
successWhilePushing = false;
}
});
using (SqlConnection con = new SqlConnection(connection))
{
con.Open();
using (SqlCommand cmd = new SqlCommand("dyndata.dbo.SP_UpdatePushedStatus", con))
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@stocknumbers", string.Join(",", stack.Where(w => w.Pushed).Select(s => s.StockNumber).ToArray()));
cmd.ExecuteNonQuery();
}
con.Close();
}
}
catch (Exception ex)
{
clsLog.LogError("PushImageData - Error while sending HighRes stock Image urls. Error " + ex.Message);
}
return(successWhilePushing);
}
public void ProcessImage()
{
var connection = ConfigurationManager.ConnectionStrings["Connection"].ConnectionString;
DataSet imageDS = new DataSet("root");
DataTable imageDT = new DataTable("stock");
imageDT.Columns.Add("StockNumber", typeof(string));
imageDT.Columns.Add("ImageIndex", typeof(int));
imageDT.Columns.Add("ImageUrl", typeof(string));
imageDS.Tables.Add(imageDT);
Dictionary <string, int> push = new Dictionary <string, int>();
try
{
clsLog.LogInfo("ProcessImage - Getting stock numbers for downloading");
var ds = clsDB.funcExecuteSQLDS("SP_GETSTOCKNUMBER '" + Environment.MachineName + "'", connection, 300);
DataTable dt = ds.Tables[0];
clsLog.LogInfo("ProcessImage - Got stock numbers for downloading");
dt.Rows.OfType <DataRow>().ToList().ForEach(p =>
{
var imageUrls = GetImage(p["StockNumber"].ToString());
clsLog.LogInfo("ProcessImage - Got Image URLs for Stock " + p["StockNumber"].ToString());
//if (imageUrls[0] == "Specialty" || imageUrls[0] == "Offsite")
// clsDB.funcExecuteSQL(string.Format("SP_UpdateStockImages @xml='{0}',@stockstatus=3", imageDS.GetXml()), connection);
//else if (string.IsNullOrEmpty(imageUrls[0]))
// clsDB.funcExecuteSQL(string.Format("SP_UpdateStockImages @xml='{0}',@stockstatus=2", imageDS.GetXml()), connection);
//else
//{
// imageDT.Rows.Clear();
for (int i = 0; i < 10; i++)
{
imageDT.Rows.Add(imageDT.NewRow());
imageDT.Rows[imageDT.Rows.Count - 1]["StockNumber"] = p["StockNumber"].ToString();
imageDT.Rows[imageDT.Rows.Count - 1]["ImageIndex"] = i;
imageDT.Rows[imageDT.Rows.Count - 1]["ImageUrl"] = imageUrls[i];
}
//clsDB.funcExecuteSQL(string.Format("SP_UpdateStockImages @xml='{0}'", imageDS.GetXml()), connection);
//}
clsLog.LogInfo("ProcessImage - HighRes Image URLs saved");
clsLog.LogInfo("ProcessImage - Sending Stock Image URLs " + p["StockNumber"].ToString());
var pushedSuccessful = true;
if (imageUrls[0] == "Specialty" || imageUrls[0] == "Offsite")
{
push.Add(p["StockNumber"].ToString(), 3);
}
else if (string.IsNullOrEmpty(imageUrls[0]))
{
push.Add(p["StockNumber"].ToString(), 2);
}
else
{
for (int i = 0; i < 10; i++)
{
var imageinfo = new ImageInformationDto()
{
StockNumber = p["StockNumber"].ToString(),
FileName = p["StockNumber"].ToString() + "_" + i,
ImageByteArray = GetImageBytes(imageUrls[i])
};
clsLog.LogInfo("ProcessImage - Sending Stock Image URLs " + p["StockNumber"].ToString() + " Index " + i);
var request = new ImageUploadRequest()
{
UserRequestInfo = User, ImageInformation = imageinfo
};
var response = ImageClient.UploadImageInformation(request);
if (response.WasSuccessful)
{
clsLog.LogInfo("ProcessImage - Sent Stock Image URLs " + p["StockNumber"] + "_" + i);
File.Delete(imageUrls[i]);
}
else
{
pushedSuccessful = false;
clsLog.LogError("ProcessImage - Unable to send Stock Image URLs " + p["StockNumber"] + "_" + i);
}
}
if (!push.Keys.ToList().Exists(e => p["StockNumber"].ToString() == e))
{
push.Add(p["StockNumber"].ToString(), pushedSuccessful ? 1 : 5);
}
}
//clsDB.funcExecuteSQL(string.Format("SP_UpdatePushedStatus @stocknumbers='{0}', @status='{1}'", p["StockNumber"].ToString(), pushedSuccessful ? 1 : 5), connection);
});
//-------------------------------------
clsDB.funcExecuteSQL(string.Format("SP_UpdateStockImages @xml='{0}'", imageDS.GetXml()), connection);
clsDB.funcExecuteSQL(string.Format("SP_UpdatePushedStatus @stocknumbers='{0}', @status='{1}'", string.Join(",", push.Keys), string.Join(",", push.Values)), connection);
}
catch (Exception ex)
{
clsLog.LogError("ProcessImage - Error while executing. " + ex.Message);
}
}
public IActionResult ImageUpload([FromForm] ImageUploadRequest request)
{
var path = _uploadService.UploadImage(request.Image);
return(Ok(new { path }));
}
public async Task <IActionResult> UploadAtricleImage(ImageUploadRequest request)
{
return(await MethodWrapper(async (param) =>
{
if (param == null)
{
return BadRequest();
}
if (!int.TryParse(param.Id, out int articleId) || !bool.TryParse(param.IsDefault, out bool isDefaultImage))
{
return BadRequest();
}
string fileName = $"{param.Id}_{param.Image.FileName}";
// путь к папке Files
string path = $"/Images/{fileName}";
if (System.IO.File.Exists(HostingEnvironment.WebRootPath + path))
{
ModelState.AddModelError("error", "Картинка уже была загружена.");
return BadRequest(ModelState);
}
// сохраняем файл в папку Files в каталоге wwwroot
using (var fileStream = new FileStream(HostingEnvironment.WebRootPath + path, FileMode.Create))
{
await param.Image.CopyToAsync(fileStream);
}
TorImage file = new TorImage {
ArticleId = articleId, Name = param.Image.FileName, LocalPath = path, IsDefault = isDefaultImage
};
Context.Images.Add(file);
await Context.SaveChangesAsync();
file.ExternalPath = $"{Request.Scheme}://{Request.Host.Value}/api/images/{file.Id}";
Context.Images.Update(file);
await Context.SaveChangesAsync();
if (isDefaultImage)
{
ArticlePreview articlePreview = await Context.Previews.FirstOrDefaultAsync(pre => pre.ArticleID == articleId);
// if exist old default image- remove it
if (!string.IsNullOrEmpty(articlePreview.DefaultImagePath))
{
string oldDefaultStr = articlePreview.DefaultImagePath.Split('/').LastOrDefault();
TorImage image = await Context.Images.FirstOrDefaultAsync(pre => pre.Id == int.Parse(oldDefaultStr));
System.IO.File.Delete(HostingEnvironment.WebRootPath + image.LocalPath);
Context.Images.Remove(image);
await Context.SaveChangesAsync();
}
articlePreview.DefaultImagePath = file.ExternalPath;
Context.Update(articlePreview);
await Context.SaveChangesAsync();
}
return Ok();
}, request));
}
