public string UploadPhoto(Stream stream)
{
Account account = new Account(
CLOUD_NAME,
API_KEY,
API_SECRET);
Cloudinary cloudinary = new Cloudinary(account);
var uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams()
{
File = new CloudinaryDotNet.Actions.FileDescription(Guid.NewGuid().ToString(), stream),
};
ImageUploadResult uploadResult = cloudinary.Upload(uploadParams);
return cloudinary.Api.UrlImgUp.BuildUrl(String.Format("{0}.{1}", uploadResult.PublicId, uploadResult.Format));
}
public ActionResult Task(HttpPostedFileBase fileUpload, HttpPostAttribute selboton)
{
if (fileUpload == null)
{
return View(GetImageCollection());
}
var cloudinary = new Cloudinary(
new Account(
"raisky",
"712813241936831",
"Z9cprR-2l0R51ehGj5PIsUr2d3I"));
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(fileUpload.FileName, fileUpload.InputStream),
};
var uploadResult = cloudinary.Upload(uploadParams);
var uplPath = uploadResult.Uri;
Image uploadedImage = new Image();
uploadedImage.Path = uplPath.AbsoluteUri;
uploadedImage.User = User.Identity.Name;
uploadedImage.PublicId = uploadResult.PublicId;
imageDataBase.Entry(uploadedImage).State = System.Data.Entity.EntityState.Added;
imageDataBase.SaveChanges();
return View(GetImageCollection());
}
public async Task <IActionResult> peopleDetail(PeopleDetail model)
{
var user = await GetCurrentUserAsync();
if (user != null)
{
var role = await _userManager.GetRolesAsync(user);
TempData["userRole"] = role[0];
string rid = HttpContext.Request.Form["restId"];
string sortOrder = HttpContext.Request.Form["sortOrder"];
string firstName = HttpContext.Request.Form["fname"];
string lastname = HttpContext.Request.Form["lname"];
string filepath = HttpContext.Request.Form["filePath"];
if (!string.IsNullOrEmpty(filepath))
{
CloudinaryDotNet.Account account = new CloudinaryDotNet.Account("hkm2gz727", "654416183426452", "AZJIv_WvBo1Z7gkzN-uXFVg2_BE");
Cloudinary cloudinary = new Cloudinary(account);
CloudinaryDotNet.Actions.ImageUploadParams uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams();
uploadParams.File = new CloudinaryDotNet.Actions.FileDescription(filepath);
CloudinaryDotNet.Actions.ImageUploadResult uploadResult = await cloudinary.UploadAsync(uploadParams);
string url = cloudinary.Api.UrlImgUp.BuildUrl(String.Format("{0}.{1}", uploadResult.PublicId, uploadResult.Format));
model.imageUrl = url;
}
else
{
string imageurl = HttpContext.Request.Form["imageurl"];
model.imageUrl = imageurl;
}
model.userId = user.Id;
model.firstName = firstName;
model.lastName = lastname;
model.restaurantId = Convert.ToInt32(rid);
model.createdDate = DateTime.Now;
model.modifiedDate = DateTime.Now;
if (model.id != 0)
{
_context.PeopleDetail.Update(model);
_context.SaveChanges();
}
else
{
model.sortOrder = _context.PeopleDetail.Where(a => a.restaurantId == Convert.ToInt32(rid)).Max(a => a.sortOrder) + 1;
_context.PeopleDetail.Add(model);
_context.SaveChanges();
}
return(Redirect("~/Admin/people?resturant=" + model.restaurantId));
}
else
{
return(RedirectToAction("QuickRegister", "Account"));
}
}
public async Task <IActionResult> MenuItemDetails(MenuItemDetail model)
{
string restaurantId = HttpContext.Request.Form["restId"];
string menuCategoryId = HttpContext.Request.Form["menuCategoryId"];
var user = await GetCurrentUserAsync();
if (user != null)
{
var role = await _userManager.GetRolesAsync(user);
TempData["userRole"] = role[0];
string filepath = HttpContext.Request.Form["filePath"];
if (!string.IsNullOrEmpty(filepath))
{
CloudinaryDotNet.Account account = new CloudinaryDotNet.Account("hkm2gz727", "654416183426452", "AZJIv_WvBo1Z7gkzN-uXFVg2_BE");
Cloudinary cloudinary = new Cloudinary(account);
CloudinaryDotNet.Actions.ImageUploadParams uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams();
uploadParams.File = new CloudinaryDotNet.Actions.FileDescription(filepath);
CloudinaryDotNet.Actions.ImageUploadResult uploadResult = await cloudinary.UploadAsync(uploadParams);
string url = cloudinary.Api.UrlImgUp.BuildUrl(String.Format("{0}.{1}", uploadResult.PublicId, uploadResult.Format));
model.menuItemImageUrl = url;
}
else
{
string imageurl = HttpContext.Request.Form["imageurl"];
model.menuItemImageUrl = imageurl;
}
model.menuCategoryId = Convert.ToInt32(menuCategoryId);
model.restaurantId = Convert.ToInt32(restaurantId);
// if (ModelState.IsValid)
// {
if (model.menuItemId != 0)
{
model.createdDate = DateTime.Now;
_context.MenuItemDetail.Update(model);
_context.SaveChanges();
}
else
{
model.createdDate = DateTime.Now;
model.sortOrder = _context.MenuItemDetail.Where(a => a.restaurantId == Convert.ToInt32(restaurantId) && a.menuCategoryId == Convert.ToInt32(menuCategoryId)).Max(a => a.sortOrder) + 1;
_context.MenuItemDetail.Add(model);
_context.SaveChanges();
}
// }
return(Redirect("~/Admin/MenuItems" + "?resturant=" + model.restaurantId + "&itemtype=" + model.menuCategoryId));
//return RedirectToAction("MenuItems", "Admin");
}
else
{
return(RedirectToAction("QuickRegister", "Account"));
}
}
public void TestAdHocParams()
{
var breakpoint = new ResponsiveBreakpoint().MaxImages(5).BytesStep(20)
.MinWidth(200).MaxWidth(1000).CreateDerived(false);
ImageUploadParams uploadParams = new ImageUploadParams()
{
File = new FileDescription(m_testImagePath)
};
uploadParams.AddCustomParam("public_id", "test_ad_hoc_params_id");
uploadParams.AddCustomParam("tags", "test");
uploadParams.AddCustomParam("IgnoredEmptyParameter", "");
uploadParams.AddCustomParam("responsive_breakpoints", JsonConvert.SerializeObject(new List<ResponsiveBreakpoint> { breakpoint }));
uploadParams.AddCustomParam("IgnoredNullParameter", null);
var paramsDict = uploadParams.ToParamsDictionary();
Assert.AreEqual(3, paramsDict.Count);
Assert.IsFalse(paramsDict.ContainsKey("IgnoredEmptyParameter"));
Assert.IsFalse(paramsDict.ContainsKey("IgnoredNullParameter"));
ImageUploadResult result = m_cloudinary.Upload(uploadParams);
Assert.AreEqual(1, result.ResponsiveBreakpoints.Count);
Assert.AreEqual(5, result.ResponsiveBreakpoints[0].Breakpoints.Count);
Assert.AreEqual(1000, result.ResponsiveBreakpoints[0].Breakpoints[0].Width);
Assert.AreEqual(200, result.ResponsiveBreakpoints[0].Breakpoints[4].Width);
}
/// <summary>
/// A convenience method for uploading an image before testing
/// </summary>
/// <param name="id">The ID of the resource</param>
/// <returns>The upload results</returns>
private ImageUploadResult UploadTestResource( String id)
{
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(m_testImagePath),
PublicId = id,
Tags = "test"
};
return m_cloudinary.Upload(uploadParams);
}
public string Store(string name, Stream stream)
{
var upload = new ImageUploadParams {
File = new FileDescription(name, stream)
};
var result = cloudinary.Upload(upload);
return string.Format("{0}.{1}", result.PublicId, result.Format);
}
public string UploadPicture(string FilePath)
{
ImageUploadParams uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams()
{
File = new FileDescription(FilePath)
};
ImageUploadResult uploadResult = cloudinary.Upload(uploadParams);
string UploadedPictureURL = cloudinary.Api.UrlImgUp.BuildUrl(String.Format("{0}.{1}", uploadResult.PublicId, uploadResult.Format));
return(UploadedPictureURL);
}
public bool UploadImage(string imgName,Stream img)
{
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(imgName, img),
PublicId = imgName
};
var uploadResult = cloudinary.Upload(uploadParams);
//TODO: Дописать проверку на ошибку(не сохранилось ихображение)
return true;
}
public async Task <string> UploadFile(IFormFile file)
{
var fileStream = file.OpenReadStream();
ImageUploadParams uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams()
{
File = new FileDescription("file", fileStream)
};
ImageUploadResult uploadResult = await this.cloudinary.UploadAsync(uploadParams);
return(uploadResult.Uri.ToString());
}
public string Upload(string data)
{
Account account = new Account("dgy6x5krf", "949232162798767", "oxvzYd03K1i8lEIi5MA2ByIf590");
Cloudinary cloudinary = new Cloudinary(account);
CloudinaryDotNet.Actions.ImageUploadParams uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams()
{
File = new CloudinaryDotNet.Actions.FileDescription(data)
};
CloudinaryDotNet.Actions.ImageUploadResult uploadResult = cloudinary.Upload(uploadParams);
return(cloudinary.Api.UrlImgUp.BuildUrl(String.Format("{0}.{1}", uploadResult.PublicId, uploadResult.Format)));
}
public String UploadImage(String path)
{
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(path),
};
var uploadResult = cloudinary.Upload(uploadParams);
if (uploadResult != null)
return uploadResult.Uri.AbsoluteUri;
else
return "";
}
public async Task <IActionResult> AddPhotoForUser(int userId,
[FromForm] PhotoForCreationDto photoForCreation)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var user = await _datingRepository.GetUser(userId);
var file = photoForCreation.File;
var uploadResult = new CloudinaryDotNet.Actions.ImageUploadResult();
if (file != null && file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams()
{
File = new FileDescription(file.Name, stream),
Transformation = new Transformation().Width(500).Height(500).Crop("fill").Gravity("face")
};
uploadResult = _cloudinary.Upload(uploadParams);
}
photoForCreation.Url = uploadResult.Uri.ToString();
photoForCreation.PublicId = uploadResult.PublicId.ToString();
var photo = _mapper.Map <Photo>(photoForCreation);
if (!user.Photos.Any(u => u.IsMain))
{
photo.IsMain = true;
}
user.Photos.Add(photo);
if (await _datingRepository.SaveAll())
{
return(CreatedAtRoute("GetPhoto", new { userId = userId, id = photo.Id },
_mapper.Map <PhotoForReturnDto>(photo)));
}
return(BadRequest("Could not add the photo"));
}
throw new System.Exception("No file has been received");
}
/// <summary>
/// Method for uploading image from local host to cloudinary
/// </summary>
/// <param name="user"></param>
/// <returns>Cloudinary link(string) of uploaded picture</returns>
private string CloudinaryUpload(Models.RegisterBindingModel user)
{
var cloudPath = Server.MapPath(user.ProfileUrl);
Account acount = new Account("gigantor", "986286566519458", "GT87e1BTMnfLut1_gXhSH0giZPg");
Cloudinary cloudinary = new Cloudinary(acount);
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(cloudPath)
};
var uploadResult = cloudinary.Upload(uploadParams);
string n = uploadResult.Uri.AbsoluteUri;
return user.ProfileUrl = n;
}
public String UploadImage(String name, Stream stream, String guid)
{
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(name, stream),
PublicId = guid
};
var uploadResult = cloudinary.Upload(uploadParams);
if (uploadResult != null)
return uploadResult.Uri.AbsoluteUri;
else
return "";
}
/// <summary>
/// Method for uploading image from local host to cloudinary
/// </summary>
/// <param name="user"></param>
/// <returns>Cloudinary link(string) of uploaded picture</returns>
private string CloudinaryUpload(Course course)
{
var cloudPath = System.Web.Hosting.HostingEnvironment.MapPath(course.PictureUrl);
Account acount = new Account("gigantor", "986286566519458", "GT87e1BTMnfLut1_gXhSH0giZPg");
Cloudinary cloudinary = new Cloudinary(acount);
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(cloudPath)
};
var uploadResult = cloudinary.Upload(uploadParams);
string n = uploadResult.Uri.AbsoluteUri;
return course.PictureUrl = n;
}
internal static String uploadImage(string filePath, string publicID)
{
//CloudinaryDotNet.Cloudinary cloudinary = new CloudinaryDotNet.Cloudinary();
//CloudinaryDotNet.Account account = new CloudinaryDotNet.Account("hmtca4hsp", "551419468127826", "6CRKqZzHmHxqCvpLaObNj2Hmsis");
CloudinaryDotNet.Account account = new CloudinaryDotNet.Account("hiisiwhue", "579971361974369", "bHspTdlzXHwF3uoLrEu5yb9a0b0");
CloudinaryDotNet.Cloudinary cloudinary = new CloudinaryDotNet.Cloudinary(account);
CloudinaryDotNet.Actions.ImageUploadParams uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams()
{
File = new CloudinaryDotNet.Actions.FileDescription(filePath),//@"C:\Users\David\Downloads\etgarPlusWebsite-master\etgarPlusWebsite\etgarPlus\images\1.png"),
PublicId = publicID
};
CloudinaryDotNet.Actions.ImageUploadResult uploadResult = cloudinary.Upload(uploadParams);
string url = cloudinary.Api.UrlImgUp.BuildUrl(publicID + filePath.Substring(filePath.LastIndexOf(".")));
return url;
}
public string UploadPhoto(Stream stream, int height, int width)
{
Account account = new Account(
CLOUD_NAME,
API_KEY,
API_SECRET);
Cloudinary cloudinary = new Cloudinary(account);
var uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams()
{
File = new CloudinaryDotNet.Actions.FileDescription(Guid.NewGuid().ToString(), stream),
};
ImageUploadResult uploadResult = cloudinary.Upload(uploadParams);
return
cloudinary.Api.UrlImgUp.Transform(new Transformation().Width(width).Height(height).Crop("fill"))
.BuildUrl(String.Format("{0}.{1}", uploadResult.PublicId, uploadResult.Format));
}
public string UploadPhoto(Stream stream)
{
Account account = new Account(
CLOUD_NAME,
API_KEY,
API_SECRET);
Cloudinary cloudinary = new Cloudinary(account);
var uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams()
{
File = new CloudinaryDotNet.FileDescription(Guid.NewGuid().ToString(), stream),
};
ImageUploadResult uploadResult = cloudinary.Upload(uploadParams);
//var result = cloudinary.Api.UrlImgUp.BuildUrl(String.Format("ekihire_img{0}.{1}", uploadResult.PublicId, uploadResult.Format));
var result = uploadResult.Url.ToString();
return(result);
}
internal static String uploadImage(String filePath, String publicId)
{
CloudinaryDotNet.Account account = new CloudinaryDotNet.Account("hmtca4hsp", "551419468127826", "6CRKqZzHmHxqCvpLaObNj2Hmsis");
CloudinaryDotNet.Cloudinary cloudinary = new CloudinaryDotNet.Cloudinary(account);
CloudinaryDotNet.Actions.ImageUploadParams uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams()
{
File = new CloudinaryDotNet.Actions.FileDescription(filePath),//@"C:\Users\David\Downloads\etgarPlusWebsite-master\etgarPlusWebsite\etgarPlus\images\1.png"),
PublicId = "4" //publicId
};
String url = cloudinary.Api.UrlImgUp.BuildUrl(publicId + filePath.Substring(filePath.LastIndexOf(".")));
Debug.WriteLine(url);
return url;
}
public async Task<IEnumerable<Photo>> Add(HttpRequestMessage request)
{
var streamProvider = new MultipartMemoryStreamProvider();
await request.Content.ReadAsMultipartAsync(streamProvider);
List<Photo> photosSaved = new List<Photo>();
foreach (HttpContent ctnt in streamProvider.Contents)
{
using (Stream imageStream = await ctnt.ReadAsStreamAsync())
{
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(ctnt.Headers.ContentDisposition.FileName, imageStream),
};
ImageUploadResult uploadResult = await _cloudinary.UploadAsync(uploadParams);
photosSaved.Add(new Photo { Uri = uploadResult.SecureUri.ToString() });
}
}
return photosSaved;
}
/// <summary>
/// save an image to cloudinary
/// </summary>
/// <param name="stream">stream representing the image file to be saved</param>
/// <param name="fileName">name of the file</param>
/// <param name="tags">any tags to go with the image in cloudinary</param>
/// <returns></returns>
public ImageSaveResult Save(Stream stream, string fileName,string[] tags)
{
if (string.IsNullOrEmpty(fileName))
throw new ArgumentException("fileName parameter must be initilaised");
if(stream==null)
throw new ArgumentException("Stream parameter cannot be null");
using (stream)
{
stream.Seek(0, SeekOrigin.Begin); //go to the start of the stream
//the upload params are sent to cloudinary
var uploadParams = new ImageUploadParams {File = new FileDescription(fileName, stream)};
//get the tags in the right format for cloudinary upload
var tagString = ToTags(tags);
if (!string.IsNullOrEmpty(tagString))
uploadParams.Tags = tagString;
ImageUploadResult uploadResult;
try
{
uploadResult = _cloudinary.Upload(uploadParams); //upload the image and other details
}
catch (Exception ex)
{
return new ImageSaveResult { ErrorMessage = ex.Message, Error = true };
}
if (uploadResult.Error != null && uploadResult.Error.Message.Length > 0)
return new ImageSaveResult {ErrorMessage = uploadResult.Error.Message, Error = true};
return new ImageSaveResult
{
Error = false,
PublicID = uploadResult.PublicId,
SecureURL = _cloudinary.Api.UrlImgUp.BuildUrl(String.Format("{0}.{1}", uploadResult.PublicId, uploadResult.Format)),
ThumbnailURL = _cloudinary.Api.UrlImgUp.Transform(new Transformation().Width(70).Height(70).Radius("max").Crop("thumb").Gravity("face")).BuildUrl(String.Format("{0}.{1}", uploadResult.PublicId, uploadResult.Format)),
URL = uploadResult.Uri.AbsoluteUri
};
}
}
protected void UploadComplete(object sender, AjaxControlToolkit.AjaxFileUploadEventArgs e)
{
try
{
Account account = new Account("dlyvxs7of", "634626974285569", "FtB_0jhcmFypFS7QTwCBKcPRGzE");
Cloudinary cloudinary = new Cloudinary(account);
ImageUploadParams uploadParams = new ImageUploadParams()
{
File = new FileDescription("file", new MemoryStream(e.GetContents()))
};
ImageUploadResult uploadResult = cloudinary.Upload(uploadParams);
HEWDataContext context = new HEWDataContext();
context.ProjectsImages.InsertOnSubmit(new ProjectsImage
{ImgPublicID = uploadResult.PublicId, ProjectID = int.Parse(Request.QueryString["ProjectID"])});
context.SubmitChanges();
}
catch (Exception)
{
}
}
/// <summary>
/// Uploads the image.
/// </summary>
/// <param name="imageLink">The image link.</param>
/// <returns></returns>
public string UploadImage(string imageLink)
{
if (imageLink != null)
{
if (imageLink.StartsWith("http"))
{
return imageLink;
}
string pattern = "data:.*?base64,";
string base64string = Regex.Replace(imageLink, pattern, "");
Stream imageStream = new MemoryStream(Convert.FromBase64String(base64string));
var uploadParams = new ImageUploadParams
{
File = new FileDescription("Picture", imageStream)
};
var uploadResult = cloud.Upload(uploadParams);
if (uploadResult != null)
{
return uploadResult.Uri.AbsoluteUri;
}
}
return null;
}
public void TestUploadLocalImage()
{
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(m_testImagePath)
};
var uploadResult = m_cloudinary.Upload(uploadParams);
Assert.AreEqual(1920, uploadResult.Width);
Assert.AreEqual(1200, uploadResult.Height);
Assert.AreEqual("jpg", uploadResult.Format);
var checkParams = new SortedDictionary<string, object>();
checkParams.Add("public_id", uploadResult.PublicId);
checkParams.Add("version", uploadResult.Version);
var api = new Api(m_account);
string expectedSign = api.SignParameters(checkParams);
Assert.AreEqual(expectedSign, uploadResult.Signature);
}
private string HandleFileUpload(ref Photo photo)
{
string filePath = @"~\Images\defaultAccomodationPhoto.jpg";
if (Request.Files.Count > 0)
{
HttpPostedFileBase file = Request.Files[0];
if (file.ContentLength > 0 && _allowedTypes.Contains(file.ContentType))
{
try
{
using (var bitmap = new Bitmap(file.InputStream))
{
}
}
catch
{
ModelState.AddModelError("PhotoUrl", "The file type is not supported");
return "none";
}
string fileName = Path.GetFileName(file.FileName);
filePath = Path.Combine(@"~\Images\Photos", fileName);
string fullPath = Path.Combine(Server.MapPath(@"~\Images\Photos"), fileName);
file.SaveAs(fullPath);
Account account = new Account(
"bitbooking",
"131162311141994",
"yqy4VSrjuxaGeP8BUMgHwTozpfw");
Cloudinary cloudinary = new Cloudinary(account);
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(fullPath)
};
var uploadResult = cloudinary.Upload(uploadParams);
FileInfo uploadedFileToServer = new FileInfo(fullPath);
uploadedFileToServer.Delete();
return uploadResult.Uri.AbsolutePath; //new photo URL from Cloudinary
}
else
{
if (file.ContentLength > 0 && !_allowedTypes.Contains(file.ContentType))
{
ModelState.AddModelError("PhotoUrl", "The file type is not supported");
return "none";
}
}
}
//photo.PhotoUrl = filePath;
return filePath;
}
public void TestListResourcesByPrefix()
{
// should allow listing resources by prefix
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(m_testImagePath),
PublicId = "testlistblablabla",
Context = new StringDictionary("context=abc")
};
m_cloudinary.Upload(uploadParams);
var result = m_cloudinary.ListResourcesByPrefix("testlist", true, true, true);
Assert.IsTrue(result.Resources.Where(res => res.PublicId.StartsWith("testlist")).Count() == result.Resources.Count());
Assert.IsTrue(result.Resources.Where(res => (res.Context == null ? false : res.Context["custom"]["context"].ToString() == "abc")).Count() > 0);
}
public ActionResult SaveUploadedFile()
{
bool isSavedSuccessfully = true;
string fName = "";
string str = "";
try
{
foreach (string fileName in Request.Files)
{
HttpPostedFileBase file = Request.Files[fileName];
//Save file content goes here
fName = file.FileName;
if (file != null && file.ContentLength > 0)
{
var originalDirectory = new DirectoryInfo(string.Format("{0}Images\\WallImages", Server.MapPath(@"\")));
string pathString = System.IO.Path.Combine(originalDirectory.ToString(), "imagepath");
var fileName1 = Path.GetFileName(file.FileName);
bool isExists = System.IO.Directory.Exists(pathString);
if (!isExists)
System.IO.Directory.CreateDirectory(pathString);
var path = string.Format("{0}\\{1}", pathString, file.FileName);
file.SaveAs(path);
Account account = new Account(
"kuzzya",
"649899148786625",
"Em9LZocDSzlf5Jf9ikhTRKwvuhY");
Cloudinary cloudinary = new Cloudinary(account);
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(path)
};
var uploadResult = cloudinary.Upload(uploadParams);
str = uploadResult.Uri.AbsoluteUri;
}
}
}
catch (Exception ex)
{
isSavedSuccessfully = false;
}
if (isSavedSuccessfully)
{
//return Json(new { Message = fName });
return Json(new { Message = "Successful", name = str });
}
else
{
return Json(new { Message = "Error in saving file" });
}
}
public void TestListResourcesByTag()
{
// should allow listing resources by tag
var file = new FileDescription(m_testImagePath);
var tag = "teslistresourcesbytag1";
m_cloudinary.DeleteResourcesByTag(tag);
var uploadParams = new ImageUploadParams()
{
File = file,
Tags = tag + ",beauty"
};
m_cloudinary.Upload(uploadParams);
uploadParams = new ImageUploadParams()
{
File = file,
Tags = tag
};
m_cloudinary.Upload(uploadParams);
var result = m_cloudinary.ListResourcesByTag(tag);
Assert.AreEqual(2, result.Resources.Count());
m_cloudinary.DeleteResourcesByTag(tag);
}
//Post : Admin/RestaurantDetails/
public async Task <IActionResult> RestaurantDetails(RestaurantDetail model)
{
string ddBrakTimeFrom = HttpContext.Request.Form["ddBrakTimeFrom"];
string ddBrakTimeTo = HttpContext.Request.Form["ddBreakTimingTO"];
var user = await GetCurrentUserAsync();
if (user != null)
{
var role = await _userManager.GetRolesAsync(user);
TempData["userRole"] = role[0];
string aa = HttpContext.Request.Form["cats"];
string filename = HttpContext.Request.Form["file"];
string filepath = HttpContext.Request.Form["filePath"];
if (!string.IsNullOrEmpty(filepath))
{
CloudinaryDotNet.Account account = new CloudinaryDotNet.Account("hkm2gz727", "654416183426452", "AZJIv_WvBo1Z7gkzN-uXFVg2_BE");
Cloudinary cloudinary = new Cloudinary(account);
CloudinaryDotNet.Actions.ImageUploadParams uploadParams = new CloudinaryDotNet.Actions.ImageUploadParams();
uploadParams.File = new CloudinaryDotNet.Actions.FileDescription(filepath);
CloudinaryDotNet.Actions.ImageUploadResult uploadResult = await cloudinary.UploadAsync(uploadParams);
string url = cloudinary.Api.UrlImgUp.BuildUrl(String.Format("{0}.{1}", uploadResult.PublicId, uploadResult.Format));
model.mainImageUrl = url;
}
else
{
string imageurl = HttpContext.Request.Form["imageurl"];
model.mainImageUrl = imageurl;
}
model.timing1 = model.timing1;
model.timing2 = model.timing2;
if (model.id != 0)
{
model.userId = model.userId;
model.categoryIds = aa;
model.modifiedDate = DateTime.Now;
_context.RestaurantDetail.Update(model);
_context.SaveChanges();
}
else
{
model.userId = user.Id;
model.categoryIds = aa;
model.createdDate = DateTime.Now;
model.modifiedDate = DateTime.Now;
model.sortOrder = _context.RestaurantDetail.Max(a => a.sortOrder) + 1;
_context.RestaurantDetail.Add(model);
_context.SaveChanges();
}
var restId = _context.RestaurantDetail.Max(a => a.id);
MenuCategoryDetail objmenucats = new MenuCategoryDetail();
objmenucats.createdDate = DateTime.Now;
objmenucats.isEnabled = true;
objmenucats.parentMenuCategoryId = null;
objmenucats.menuCategoryDesc = null;
objmenucats.menuCategoryName = "Breakfast";
objmenucats.modifiedDate = DateTime.Now;
objmenucats.restaurantId = restId;
objmenucats.sortOrder = 1;
_context.MenuCategoryDetail.Add(objmenucats);
_context.SaveChanges();
MenuCategoryDetail objmenucats1 = new MenuCategoryDetail();
objmenucats1.createdDate = DateTime.Now;
objmenucats1.isEnabled = true;
objmenucats.parentMenuCategoryId = null;
objmenucats1.menuCategoryDesc = null;
objmenucats1.menuCategoryName = "Lunch";
objmenucats1.modifiedDate = DateTime.Now;
objmenucats1.restaurantId = restId;
objmenucats1.sortOrder = 2;
_context.MenuCategoryDetail.Add(objmenucats1);
_context.SaveChanges();
MenuCategoryDetail objmenucats2 = new MenuCategoryDetail();
objmenucats2.createdDate = DateTime.Now;
objmenucats2.isEnabled = true;
objmenucats2.menuCategoryDesc = null;
objmenucats.parentMenuCategoryId = null;
objmenucats2.menuCategoryName = "Dinner";
objmenucats2.modifiedDate = DateTime.Now;
objmenucats2.restaurantId = restId;
objmenucats2.sortOrder = 3;
_context.MenuCategoryDetail.Add(objmenucats2);
_context.SaveChanges();
return(RedirectToAction("Index", "Admin"));
}
else
{
return(RedirectToAction("QuickRegister", "Account"));
}
}
/// <summary>
/// Uploads image on cloudinary
/// </summary>
/// <returns></returns>
private string UploadImage()
{
Account account = new Account("dvnnqotru", "252251816985341", "eqxRrtlVyiWA5-WCil_idtLzP6c");
Cloudinary cloudinary = new Cloudinary(account);
if (Request.Files.Count > 0) //is there file to upload
{
HttpPostedFileBase file = Request.Files[0];
if (file.ContentLength > 0 && _allowedTypes.Contains(file.ContentType))
{
try //test is selected file a image
{
using (var bitmap = new Bitmap(file.InputStream))
{
if (bitmap.Width < 110 || bitmap.Height < 140) //minimum size of picture is 110x140
{
ModelState.AddModelError("PictureUrl", "Picture is too small");
return null;
}
}
}
catch
{
ModelState.AddModelError("PictureUrl", "The file type is not supported");
return null;
}
file.SaveAs(Path.Combine(Server.MapPath("~/Content/"), file.FileName));
var uploadParams = new ImageUploadParams() //upload to cloudinary
{
File = new FileDescription(Path.Combine(Server.MapPath("~/Content/"), file.FileName)),
Transformation = new Transformation().Crop("fill").Width(110).Height(140)
};
var uploadResult = cloudinary.Upload(uploadParams);
System.IO.File.Delete(Path.Combine(Server.MapPath("~/Content/"), file.FileName));
return uploadResult.Uri.AbsolutePath;
}
else
{
ModelState.AddModelError("PictureUrl", "The file type is not supported");
return null;
}
}
return null;
}
/// <summary>
/// Uploads an image file to cloudinary.
/// </summary>
/// <param name="parameters">Parameters of image uploading .</param>
/// <returns>Results of image uploading.</returns>
public ImageUploadResult Upload(ImageUploadParams parameters)
{
string uri = m_api.ApiUrlImgUpV.BuildUrl();
ResetInternalFileDescription(parameters.File);
using (HttpWebResponse response = m_api.Call(HttpMethod.POST, uri, parameters.ToParamsDictionary(), parameters.File))
{
return ImageUploadResult.Parse(response);
}
}
private String UploadImage(HttpPostedFileBase imageBase, CloudinaryDotNet.Cloudinary cloudinary)
{
var fileName = System.IO.Path.GetFileName(imageBase.FileName);
imageBase.SaveAs(Server.MapPath("~/" + fileName));
ImageUploadParams uploadParams = new ImageUploadParams()
{
File = new FileDescription(Server.MapPath("~/" + fileName)),
PublicId = User.Identity.Name + DateTime.Now,
};
ImageUploadResult uploadResult = cloudinary.Upload(uploadParams);
System.IO.File.Delete(Server.MapPath("~/" + fileName));
return uploadResult.Uri.ToString();
}
public void TestEagerTransformationList()
{
List<Transformation> list = new List<Transformation>(){
new EagerTransformation().SetFormat("jpg").Crop("scale").Width(2.0),
new EagerTransformation(new Transformation().Width(10),new Transformation().Angle(10)),
new Transformation().Width(20).Height(20)
};
ImageUploadParams uploadParams = new ImageUploadParams()
{
EagerTransforms = list
};
SortedDictionary<string, object> dict = uploadParams.ToParamsDictionary();
Assert.AreEqual("c_scale,w_2.0/jpg|w_10/a_10|h_20,w_20", dict["eager"]);
}
public ActionResult Save(string t, string l, string h, string w, string fileName)
{
try
{
// Calculate dimensions
var top = Convert.ToInt32(t.Replace("-", "").Replace("px", ""));
var left = Convert.ToInt32(l.Replace("-", "").Replace("px", ""));
var height = Convert.ToInt32(h.Replace("-", "").Replace("px", ""));
var width = Convert.ToInt32(w.Replace("-", "").Replace("px", ""));
// Get file from temporary folder
var fn = Path.Combine(Server.MapPath(MapTempFolder), Path.GetFileName(fileName));
// ...get image and resize it, ...
var img = new WebImage(fn);
img.Resize(width, height);
// ... crop the part the user selected, ...
img.Crop(top, left, img.Height - top - AvatarStoredHeight, img.Width - left - AvatarStoredWidth);
// ... delete the temporary file,...
System.IO.File.Delete(fn);
// ... and save the new one.
var newFileName = Path.GetFileName(fn);
img.Save(Server.MapPath("~/" + newFileName));
Account account = new Account(
"lifedemotivator",
"366978761796466",
"WMYLmdaTODdm4U6VcUGhxapkcjI"
);
ImageUploadResult uploadResult = new ImageUploadResult();
CloudinaryDotNet.Cloudinary cloudinary = new CloudinaryDotNet.Cloudinary(account);
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(Server.MapPath("~/" + newFileName)),
PublicId = User.Identity.Name + newFileName,
};
uploadResult = cloudinary.Upload(uploadParams);
System.IO.File.Delete(Server.MapPath("~/" + newFileName));
UrlAvatar = uploadResult.Uri.ToString();
return Json(new { success = true, avatarFileLocation = UrlAvatar });
}
catch (Exception ex)
{
return Json(new { success = false, errorMessage = "Unable to upload file.\nERRORINFO: " + ex.Message });
}
}
public JsonResult Upload()
{
List<ImageUploadResult> list = new List<ImageUploadResult>();
JsonResult trem = new JsonResult();
string fileName = "";
ImageUploadResult uploadResult = new ImageUploadResult();
ImageUploadResult uploadResult2 = new ImageUploadResult();
ImageUploadParams uploadParams = new ImageUploadParams();
ImageUploadParams uploadParams2 = new ImageUploadParams();
Account account = new Account(
"aniknaemm",
"173434464182424",
"p3LleRLwWAxpm9yU3CHT63qKp_E");
CloudinaryDotNet.Cloudinary cloudinary = new CloudinaryDotNet.Cloudinary(account);
foreach (string file in Request.Files)
{
var upload = Request.Files[file];
if (upload != null)
{
fileName = System.IO.Path.GetFileName(upload.FileName);
upload.SaveAs(Server.MapPath("~/" + fileName));
uploadParams = new ImageUploadParams()
{
File = new FileDescription(Server.MapPath("~/" + fileName)),
PublicId = User.Identity.Name + fileName,
};
}
}
foreach (string file in Request.Form)
{
var upload = Request.Form[file];
if (upload != null)
{
string x = upload.Replace("data:image/png;base64,", "");
byte[] imageBytes = Convert.FromBase64String(x);
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
ms.Write(imageBytes, 0, imageBytes.Length);
System.Drawing.Image image = System.Drawing.Image.FromStream(ms, true);
image.Save(Server.MapPath("~/img.png"), System.Drawing.Imaging.ImageFormat.Png);
uploadParams2 = new ImageUploadParams()
{
File = new FileDescription(Server.MapPath("~/img.png")),
PublicId = User.Identity.Name + fileName +"demotevators"
};
}
}
uploadResult = cloudinary.Upload(uploadParams);
list.Add(uploadResult);
uploadResult2 = cloudinary.Upload(uploadParams2);
list.Add(uploadResult2);
System.IO.File.Delete(Server.MapPath("~/" + fileName));
System.IO.File.Delete(Server.MapPath("~/img.png"));
return Json(list, JsonRequestBehavior.AllowGet);
}
private String UploadImageFabricJS(String imageFile, CloudinaryDotNet.Cloudinary cloudinary)
{
string x = imageFile.Replace("data:image/png;base64,", "");
byte[] imageBytes = Convert.FromBase64String(x);
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
ms.Write(imageBytes, 0, imageBytes.Length);
System.Drawing.Image image = System.Drawing.Image.FromStream(ms, true);
image.Save(Server.MapPath("~/image.png"), System.Drawing.Imaging.ImageFormat.Png);
ImageUploadParams uploadParams = new ImageUploadParams()
{
File = new FileDescription(Server.MapPath("~/image.png")),
PublicId = User.Identity.Name + DateTime.Now + "demotevators"
};
ImageUploadResult uploadResult = cloudinary.Upload(uploadParams);
System.IO.File.Delete(Server.MapPath("~/image.png"));
return uploadResult.Uri.ToString();
}
public void TestResourcesCursor()
{
// should allow listing resources with cursor
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(m_testImagePath),
PublicId = "testlistresources1"
};
m_cloudinary.Upload(uploadParams);
uploadParams = new ImageUploadParams()
{
File = new FileDescription(m_testImagePath),
PublicId = "testlistresources2"
};
m_cloudinary.Upload(uploadParams);
var listParams = new ListResourcesParams()
{
ResourceType = ResourceType.Image,
MaxResults = 1
};
var result1 = m_cloudinary.ListResources(listParams);
Assert.IsNotNull(result1.Resources);
Assert.AreEqual(1, result1.Resources.Length);
Assert.IsFalse(String.IsNullOrEmpty(result1.NextCursor));
listParams.NextCursor = result1.NextCursor;
var result2 = m_cloudinary.ListResources(listParams);
Assert.IsNotNull(result2.Resources);
Assert.AreEqual(1, result2.Resources.Length);
Assert.AreNotEqual(result1.Resources[0].PublicId, result2.Resources[0].PublicId);
}
