public UploadImageResult Upload(Stream stream, string fileName)
{
using (var context = new UploadImageContext(stream, fileName))
{
return(Upload(context));
}
}
public ActionResult AddOrEdit(imageModel img)
{
if (img.ImageUpload != null)
{
string fileName = Path.GetFileNameWithoutExtension(img.ImageUpload.FileName);
string extension = Path.GetExtension(img.ImageUpload.FileName);
fileName = img.Name + extension;
img.ImagePath = "/File/image/" + fileName;
img.ImageUpload.SaveAs(Path.Combine(Server.MapPath("/File/image/"), fileName));
}
using (UploadImageContext db = new UploadImageContext())
{
if (img.Id == 0)
{
image obj = new image();
obj.ImagePath = img.ImagePath;
obj.Name = img.Name;
db.images.Add(obj);
db.SaveChanges();
return(Json(new { success = true, message = "Saved successfully!!!" }, JsonRequestBehavior.AllowGet));
}
else
{
db.Entry(img).State = EntityState.Modified;
db.SaveChanges();
return(Json(new { success = true, message = "Updated successfully!!!" }, JsonRequestBehavior.AllowGet));
}
}
}
public async Task <IActionResult> Index(SearchCriteria searchCriteria)
{
var formCollection = await HttpContext.Request.ReadFormAsync().ConfigureAwait(false);
if (!string.IsNullOrWhiteSpace(formCollection["DateOfBirthFrom"]))
{
searchCriteria.DateOfBirthFrom = DateTime.ParseExact(formCollection["DateOfBirthFrom"], "dd/MM/yyyy", null);
ModelState.Remove("DateOfBirthFrom");
}
if (!string.IsNullOrWhiteSpace(formCollection["DateOfBirthTo"]))
{
searchCriteria.DateOfBirthTo = DateTime.ParseExact(formCollection["DateOfBirthTo"], "dd/MM/yyyy", null);
ModelState.Remove("DateOfBirthTo");
}
UploadImageContext context = HttpContext.RequestServices.GetService(typeof(UploadImageContext)) as UploadImageContext;
var query = MakeQuery(searchCriteria);
List <PersonModel> personList = context.GetPersons(query);
searchCriteria.persons = personList;
searchCriteria.Query = query;
await InitializeSearchCriteria();
return(View(searchCriteria));
}
public UploadImageResult Upload(HttpPostedFileBase file)
{
using (var context = new UploadImageContext(file))
{
return(Upload(context));
}
}
public UploadImageResult Upload(string fileName)
{
_logger.Debug("Upload Image FileName\n\r==================");
using (var context = new UploadImageContext(fileName))
{
return(Upload(context));
}
}
public ActionResult Delete(int id)
{
using (UploadImageContext db = new UploadImageContext())
{
image img = db.images.Where(x => x.Id == id).FirstOrDefault <image>();
db.images.Remove(img);
db.SaveChanges();
return(Json(new { success = true, message = "Deleted successfully!!!" }, JsonRequestBehavior.AllowGet));
}
}
public ActionResult AddOrEdit(int id = 0)
{
if (id == 0)
{
return(View(new imageModel()));
}
else
{
using (UploadImageContext db = new UploadImageContext())
{
return(View(db.images.Where(x => x.Id == id).FirstOrDefault <image>()));
}
}
}
public ActionResult ViewAll()
{
using (UploadImageContext db = new UploadImageContext())
{
List <imageModel> imgList = db.images
.Select(x => new imageModel
{
Id = x.Id,
Name = x.Name,
ImagePath = x.ImagePath
}).ToList();
return(Json(new { data = imgList }, JsonRequestBehavior.AllowGet));
}
}
private void SaveSourceImage(UploadImageContext context)
{
_logger.Info("ImageSourceProcesser");
try
{
string fileName = FileUtils.SaveImage(context.ImageStream, context.ImageExt, ImageStoreSettings.ImageDir);
context.ImageUrl = ImageStoreSettings.ImageUrl + fileName;
_logger.InfoFormat("ImageSourceProcesser Complete, fileName:{0}, compressUrl:{1}", fileName, context.CompressUrl);
}
catch (Exception ex)
{
_logger.Error(ex.Message);
_logger.Error(ex.StackTrace);
}
}
public override int Process(UploadImageContext context)
{
_logger.Debug("ImageThumbnailProcess");
try
{
Size thumbnailSize = GetThumbnailSize(context.ImageStream);
var stream = ImageCompress.CompressImage(context.ImageFormat, context.ImageStream, thumbnailSize, false);
string fileName = FileUtils.SaveImage(stream, context.ImageExt, ImageStoreSettings.ThumbDir);
context.ThumbUrl = ImageStoreSettings.ThumbUrl + fileName;
_logger.InfoFormat("ImageSourceProcesser Complete, fileName:{0}, compressUrl:{1}", fileName, context.CompressUrl);
}
catch (Exception e)
{
_logger.Error(e.Message);
return(ImageErrorMessage.ImageUndefinedError);
}
return(NextProcesser.Process(context));
}
private UploadImageResult Upload(UploadImageContext context)
{
_logger.Debug("Upload Image \n\r==================");
int returnCode = _checkProcesser.Process(context);
bool success = (returnCode == ImageErrorMessage.ImageUploadSucess);
var result = new UploadImageResult
{
Success = success,
ImageName = context.FileName,
ImageUrl = context.ImageUrl,
ThumbImageUrl = context.ThumbUrl,
CompressImageUrl = context.CompressUrl,
ReturnCode = returnCode
};
_logger.DebugFormat("the image {0} upload succeed!the image path was:{1}, thumb image path:{2}", result.ImageName, result.ImageUrl, result.ThumbImageUrl);
_logger.Debug("\n\r===========================================");
return(result);
}
public override int Process(UploadImageContext context)
{
if (IsFileSizeExtendMaxSize(context.ContentContentLength))
{
_logger.InfoFormat("图片超过了大小，图片大小为{0}", context.ContentContentLength);
return(ImageErrorMessage.ImageTooLarge);
}
if (IsFileSizeIsNegative(context.ContentContentLength))
{
_logger.Info("图片大小为负数");
return(ImageErrorMessage.ImageNegative);
}
if (!IsImageTypeSupport(context.ImageExt))
{
_logger.InfoFormat("图片后缀为{0},后缀不支持", context.ImageExt);
return(ImageErrorMessage.ImageTypeNotSupport);
}
return(NextProcesser.Process(context));
}
public Size GetImageSize(UploadImageContext context)
{
var sourceImgSize = new Size();
using (var originalImage = Image.FromStream(context.ImageStream))
{
sourceImgSize.Width = originalImage.Width;
sourceImgSize.Height = originalImage.Height;
}
var width = sourceImgSize.Width;
var height = sourceImgSize.Height;
if (width > ImageConstants.MaxImageWidth)
{
var percent = ImageConstants.MaxImageWidth / (double)width;
height = (int)(percent * height);
width = ImageConstants.MaxImageWidth;
}
return(new Size {
Width = width, Height = height
});
}
public override int Process(UploadImageContext context)
{
_logger.Info("ImageCompressionProcesser");
try
{
Size size = GetImageSize(context);
var stream = ImageCompress.CompressImage(context.ImageFormat, context.ImageStream, size, true);
string fileName = FileUtils.SaveImage(stream, context.ImageExt, ImageStoreSettings.CompressDir);
context.CompressUrl = ImageStoreSettings.CompressUrl + fileName;
_logger.InfoFormat("ImageCompressionProcesser Complete, fileName:{0}, compressUrl:{1}", fileName, context.CompressUrl);
}
catch (Exception e)
{
_logger.Error(e.Message);
_logger.Error(e.StackTrace);
return(ImageErrorMessage.ImageUndefinedError);
}
return(NextProcesser.Process(context));
}
public async Task <IActionResult> Index(UploadImage model)
{
List <string> filesNotUploaded = new List <string>();
try
{
using (MemoryStream stream = new MemoryStream())
{
model.ImageUpload.CopyTo(stream);
using (ZipArchive archive = new ZipArchive(stream))
{
foreach (ZipArchiveEntry entry in archive.Entries)
{
using (Stream unzippedEntryStream = entry.Open())
{
using (MemoryStream memoryStream = new MemoryStream())
{
await unzippedEntryStream.CopyToAsync(memoryStream);
string image = Convert.ToBase64String(memoryStream.ToArray());
string formNumber = Path.GetFileNameWithoutExtension(entry.FullName);
UploadImageContext context =
HttpContext.RequestServices.GetService(typeof(UploadImageContext)) as
UploadImageContext;
bool success = context.uploadImageToDB(image, formNumber);
if (!success)
{
filesNotUploaded.Add(entry.FullName);
}
}
}
}
}
}
model.ListFormNumbers.AddRange(filesNotUploaded);
}
catch (Exception)
{
//TempData["MessageType"] = MessageTypes.Error;
//TempData["Message"] = Messages.GeneralError;
ViewBag.MessageType = MessageTypes.Error;
ViewBag.Message = Messages.GeneralError;
}
if (filesNotUploaded.Count == 0)
{
//TempData["MessageType"] = MessageTypes.Success;
//TempData["Message"] = Messages.AllImagesUploaded;
ViewBag.MessageType = MessageTypes.Success;
ViewBag.Message = Messages.AllImagesUploaded;
}
else
{
//TempData["MessageType"] = MessageTypes.Warn;
//TempData["Message"] = Messages.FewImagesUploaded;
ViewBag.MessageType = MessageTypes.Warn;
ViewBag.Message = Messages.FewImagesUploaded;
}
return(View(model));
}
public abstract int Process(UploadImageContext context);
public override int Process(UploadImageContext context)
{
SaveSourceImage(context);
return(NextProcesser.Process(context));
}
public override int Process(UploadImageContext context)
{
_logger.Debug("ImageCompressionProcesser");
return(ImageErrorMessage.ImageUploadSucess);
}
