Esempio n. 1
0
        /// <summary>
        /// Delete picture thumbs
        /// </summary>
        /// <param name="picture">Picture</param>
        protected virtual Task DeletePictureThumbs(Picture picture)
        {
            string filter             = string.Format("{0}*.*", picture.Id);
            var    thumbDirectoryPath = _mediaFileStore.GetDirectoryInfo(_thumbPath);

            if (thumbDirectoryPath != null)
            {
                string[] currentFiles = Directory.GetFiles(thumbDirectoryPath.PhysicalPath, filter, SearchOption.AllDirectories);
                foreach (string currentFileName in currentFiles)
                {
                    try
                    {
                        if (!File.Exists(currentFileName))
                        {
                            File.Delete(currentFileName);
                        }
                    }
                    catch { }
                }
            }
            return(Task.CompletedTask);
        }
Esempio n. 2
0
        public virtual async Task <IActionResult> AsyncLogoUpload()
        {
            if (!await _permissionService.Authorize(StandardPermission.ManageSettings))
            {
                return(Content("Access denied"));
            }

            var form = await HttpContext.Request.ReadFormAsync();

            var httpPostedFile = form.Files.FirstOrDefault();

            if (httpPostedFile == null)
            {
                return(Json(new
                {
                    success = false,
                    message = "No file uploaded",
                }));
            }


            var qqFileNameParameter = "qqfilename";
            var fileName            = httpPostedFile.FileName;

            if (String.IsNullOrEmpty(fileName) && form.ContainsKey(qqFileNameParameter))
            {
                fileName = form[qqFileNameParameter].ToString();
            }

            fileName = Path.GetFileName(fileName);

            var contentType = httpPostedFile.ContentType;

            var fileExtension = Path.GetExtension(fileName);

            if (!String.IsNullOrEmpty(fileExtension))
            {
                fileExtension = fileExtension.ToLowerInvariant();
            }

            if (!GetAllowedFileTypes().Contains(fileExtension))
            {
                return(Json(new
                {
                    success = false,
                    message = "File no allowed"
                }));
            }

            //contentType is not always available
            //that's why we manually update it here
            //http://www.sfsu.edu/training/mimetype.htm
            if (String.IsNullOrEmpty(contentType))
            {
                switch (fileExtension)
                {
                case ".bmp":
                    contentType = "image/bmp";
                    break;

                case ".gif":
                    contentType = "image/gif";
                    break;

                case ".jpeg":
                case ".jpg":
                case ".jpe":
                case ".jfif":
                case ".pjpeg":
                case ".pjp":
                    contentType = "image/jpeg";
                    break;

                case ".png":
                    contentType = "image/png";
                    break;

                case ".tiff":
                case ".tif":
                    contentType = "image/tiff";
                    break;

                default:
                    break;
                }
            }
            if (String.IsNullOrEmpty(contentType))
            {
                return(Json(new
                {
                    success = false,
                    message = "Unknown content type"
                }));
            }
            fileName = fileName.Replace(" ", "");
            var fileInfo = await _mediaFileStore.GetFileInfo(fileName);

            if (fileInfo == null)
            {
                try
                {
                    var filepath = _mediaFileStore.GetDirectoryInfo("");
                    if (filepath != null)
                    {
                        using (var stream = new FileStream(_mediaFileStore.Combine(filepath.PhysicalPath, fileName), FileMode.OpenOrCreate))
                        {
                            httpPostedFile.CopyTo(stream);
                        }
                        return(Json(new
                        {
                            success = true,
                            imageUrl = fileName
                        }));
                    }
                    else
                    {
                        return(Json(new
                        {
                            success = false,
                            message = "Physical path not exist"
                        }));
                    }
                }
                catch (Exception ex)
                {
                    return(Json(new
                    {
                        success = false,
                        message = ex.Message
                    }));
                }
            }
            return(Json(new
            {
                success = false,
                message = "This filename exists"
            }));
        }