protected void Page_Load(object sender, EventArgs e)
        {
            string userTempFolder = string.Empty;

            if (Request.Params["t"] != null)
            {
                userTempFolder = Request.Params["t"].ToString();
                if (!Directory.Exists(Server.MapPath("~/Media/Temp/" + userTempFolder + "/tmp/")))
                {
                    Directory.CreateDirectory(Server.MapPath("~/Media/Temp/" + userTempFolder + "/tmp/"));
                }
            }

            if (Request.Files.Count > 0 && !string.IsNullOrEmpty(userTempFolder))
            {
                int chunk = Request["chunk"] != null?int.Parse(Request["chunk"]) : 0;

                int chunks = Request["chunks"] != null?int.Parse(Request["chunks"]) : 0;

                string fileName = Request["name"] != null ? Request["name"] : string.Empty;

                HttpPostedFile fileUpload = Request.Files[0];

                var uploadPath = Server.MapPath("~/Media/Temp/" + userTempFolder + "/tmp/");
                using (var fs = new FileStream(Path.Combine(uploadPath, fileName), chunk == 0 ? FileMode.Create : FileMode.Append))
                {
                    var buffer = new byte[fileUpload.InputStream.Length];
                    fileUpload.InputStream.Read(buffer, 0, buffer.Length);

                    fs.Write(buffer, 0, buffer.Length);
                }

                if (chunks == 1 || chunk == chunks - 1) // upload complete
                {
                    string uniqueFileName = Library.Helper.getUniqueFileName(Server.MapPath("~/Media/Temp/" + userTempFolder) + @"\", fileName);

                    // move to user folder and rename accordingly
                    File.Move(Server.MapPath("~/Media/Temp/" + userTempFolder + "/tmp/" + fileName), Server.MapPath("~/Media/Temp/" + userTempFolder + "/" + uniqueFileName));

                    // create thumbnail if needed
                    FileInfo fInfo          = new FileInfo(uniqueFileName);
                    string[] imageExtension = { ".jpg", ".jpeg", ".gif", ".bmp", ".png" };
                    if (imageExtension.Contains(fInfo.Extension.ToLower()))
                    {
                        Library.FileHelper.ImageManager imgFactory = new Library.FileHelper.ImageManager("", "");
                        imgFactory.CreateThumbnail2(Server.MapPath("~/Media/Temp/" + userTempFolder + "/thumbnail/") + @"\", Server.MapPath("~/Media/Temp/" + userTempFolder + "/" + uniqueFileName));
                    }
                }
            }
        }
        //
        // CUSTOM FUNCTION
        //
        public bool RotateFile(int userId, string filename, int direction, out Library.DTO.Notification notification)
        {
            notification = new Library.DTO.Notification()
            {
                Type = Library.DTO.NotificationType.Success
            };
            try
            {
                string userFolder = FrameworkSetting.Setting.AbsoluteUserTempFolder + userId.ToString() + @"\";
                prepareStorageFolder(userFolder);
                Library.FileHelper.ImageManager imgMng = new Library.FileHelper.ImageManager("", "");
                if (direction > 0)
                {
                    direction = 1;
                }
                else
                {
                    direction = -1;
                }

                if (File.Exists(userFolder + filename))
                {
                    imgMng.RotateImage(userFolder + filename, 90 * direction);
                }
                if (File.Exists(userFolder + @"\thumbnail\" + filename))
                {
                    imgMng.RotateImage(userFolder + @"\thumbnail\" + filename, 90 * direction);
                }
            }
            catch (Exception ex)
            {
                notification.Type    = Library.DTO.NotificationType.Error;
                notification.Message = ex.Message;
                return(false);
            }

            return(true);
        }
        public bool RemoveImageFile(string fileUD)
        {
            Library.FileHelper.ImageManager imgMng = new Library.FileHelper.ImageManager(FrameworkSetting.Setting.AbsoluteFileFolder, FrameworkSetting.Setting.AbsoluteThumbnailFolder);
            using (FrameworkEntities context = CreateContext())
            {
                try
                {
                    Files _file = context.Files.FirstOrDefault(o => o.FileUD == fileUD);
                    if (_file != null)
                    {
                        if (!string.IsNullOrEmpty(_file.FileLocation))
                        {
                            try
                            {
                                imgMng.DeleteFile(_file.FileLocation);
                            }
                            catch { }
                        }

                        if (!string.IsNullOrEmpty(_file.ThumbnailLocation))
                        {
                            try
                            {
                                imgMng.DeleteFile(_file.ThumbnailLocation);
                            }
                            catch { }
                        }

                        context.Files.Remove(_file);
                        context.SaveChanges();
                    }
                    return(true);
                }
                catch { return(false); }
            }
        }
Beispiel #4
0
        public override bool DeleteData(int id, out Library.DTO.Notification notification)
        {
            notification = new Library.DTO.Notification()
            {
                Type = Library.DTO.NotificationType.Success
            };
            try
            {
                using (SubMaterialOptionMngEntities context = CreateContext())
                {
                    SubMaterialOption dbItem = context.SubMaterialOption.FirstOrDefault(o => o.SubMaterialOptionID == id);
                    if (dbItem == null)
                    {
                        notification.Message = "Sub material option not found!";
                        return(false);
                    }
                    else
                    {
                        // processing image
                        if (!string.IsNullOrEmpty(dbItem.ImageFile))
                        {
                            Library.FileHelper.ImageManager imgMng = new Library.FileHelper.ImageManager(FrameworkSetting.Setting.AbsoluteFileFolder, FrameworkSetting.Setting.AbsoluteThumbnailFolder);

                            // delete phisycal files
                            string toBeDeletedFileLocation      = "";
                            string toBeDeletedThumbnailLocation = "";
                            fwFactory.GetDBFileLocation(dbItem.ImageFile, out toBeDeletedFileLocation, out toBeDeletedThumbnailLocation);

                            if (!string.IsNullOrEmpty(toBeDeletedFileLocation))
                            {
                                try
                                {
                                    imgMng.DeleteFile(toBeDeletedFileLocation);
                                }
                                catch { }
                            }

                            if (!string.IsNullOrEmpty(toBeDeletedThumbnailLocation))
                            {
                                try
                                {
                                    imgMng.DeleteFile(toBeDeletedThumbnailLocation);
                                }
                                catch { }
                            }
                        }

                        context.SubMaterialOption.Remove(dbItem);
                        context.SaveChanges();

                        return(true);
                    }
                }
            }
            catch (Exception ex)
            {
                notification.Type    = Library.DTO.NotificationType.Error;
                notification.Message = ex.Message;
                return(false);
            }
        }
        public string CreateNoneImageFilePointer(string tmpFolder, string newFile, string oldFilePointer)
        {
            string result = string.Empty;

            Library.FileHelper.ImageManager imgMng = new Library.FileHelper.ImageManager(FrameworkSetting.Setting.AbsoluteFileFolder, FrameworkSetting.Setting.AbsoluteThumbnailFolder);

            using (FrameworkEntities context = CreateContext())
            {
                // delete phisycal files
                Files _file = context.Files.FirstOrDefault(o => o.FileUD == oldFilePointer);
                if (_file != null)
                {
                    if (!string.IsNullOrEmpty(_file.FileLocation))
                    {
                        try
                        {
                            imgMng.DeleteFile(_file.FileLocation);
                        }
                        catch { }
                        _file.FileLocation = string.Empty;
                    }

                    if (!string.IsNullOrEmpty(_file.ThumbnailLocation))
                    {
                        try
                        {
                            imgMng.DeleteFile(_file.ThumbnailLocation);
                        }
                        catch { }
                        _file.ThumbnailLocation = string.Empty;
                    }

                    // remove the file pointer if new file is empty
                    if (string.IsNullOrEmpty(newFile))
                    {
                        // remove file registration in database
                        context.Files.Remove(_file);
                        context.SaveChanges();

                        result = string.Empty;
                    }
                }

                if (!string.IsNullOrEmpty(newFile))
                {
                    // assign new file
                    string outFileFullPath, outDBFileLocation;

                    // copy the new file
                    imgMng.StoreFile(tmpFolder + newFile, out outDBFileLocation, out outFileFullPath);

                    if (File.Exists(outFileFullPath))
                    {
                        FileInfo info = new FileInfo(outFileFullPath);

                        // insert/update file registration in database
                        try
                        {
                            if (_file == null)
                            {
                                _file        = new Files();
                                _file.FileUD = System.Guid.NewGuid().ToString().ToLower().Replace("-", "");
                                context.Files.Add(_file);
                            }
                            _file.FriendlyName  = newFile;
                            _file.FileLocation  = outDBFileLocation;
                            _file.FileExtension = info.Extension;
                            _file.FileSize      = (int)info.Length;

                            context.SaveChanges();

                            result = _file.FileUD;
                        }
                        catch
                        {
                            result = string.Empty;
                        }
                    }
                }
            }

            return(result);
        }