Пример #1
0
        protected void UploadButton_Click(object sender, EventArgs e)
        {
            List <string> files;

            if (!AssetFileUpload.HasFile && AssetSourcePathDropDownList.SelectedValue == "#BROWSERUPLOAD#")
            {
                MessageLabel1.SetErrorMessage("Please select a file to upload");
                return;
            }

            if (AssetSourceSubfolderTextBox.Text.Contains("..\\"))
            {
                MessageLabel1.SetErrorMessage("Invalid source path sub-folder specified");
                return;
            }

            if (!AssetFileUpload.HasFile)
            {
                // Must be scanning Asset source paths
                // Check that we have the specified folder
                string path = Path.Combine(AssetSourcePathDropDownList.SelectedValue, AssetSourceSubfolderTextBox.Text);
                if (!Directory.Exists(path))
                {
                    MessageLabel1.SetErrorMessage("Source path specified does not exit");
                    return;
                }

                files = AssetSourcePathManager.GetAssetFiles(path);
                if (files.Count() == 0)
                {
                    MessageLabel1.SetErrorMessage("No files exist on path '" + AssetSourcePathDropDownList.SelectedValue + "'");
                    return;
                }
                // Check the radio button to see whether we are moving or copying.
                BinaryFile.SaveMode saveMode = (MoveOrCopyButtonList.SelectedValue == "M" ? BinaryFile.SaveMode.Move : BinaryFile.SaveMode.Copy);
                ProcessUpload(files, saveMode, false, path);
            }
            else
            {
                // Uploading a single file through the browser
                try
                {
                    // Save the uploaded file to disk
                    string uploadedFilePath = Path.Combine(SessionHelper.GetForCurrentSession().CreateSessionTempFolder(), AssetFileUpload.FileName);
                    AssetFileUpload.MoveTo(uploadedFilePath, MoveToOptions.Overwrite);

                    // Wrap the uploaded file in a generic BinaryFile class for use in the business layer.
                    BinaryFile file = new BinaryFile(uploadedFilePath, BinaryFile.SaveMode.Move);

                    // Ensure basic form values are valid
                    if (!PageIsValid(file))
                    {
                        return;
                    }

                    files = new List <string> {
                        uploadedFilePath
                    };

                    // Alway move the file when processing a browser uploaded file because
                    // at this stage we are playing with the temporary file.
                    ProcessUpload(files, BinaryFile.SaveMode.Move, true, string.Empty);
                }
                catch (Exception ex)
                {
                    const string message = "Unknown error occured when uploading asset(s)";
                    string       error   = (CurrentUser.UserRole == UserRole.SuperAdministrator) ? ex.ToString() : ex.Message;

                    MessageLabel1.SetErrorMessage(message, error);
                    ExceptionHandler.HandleException(ex, message);
                }
            }
        }
Пример #2
0
        /// <summary>
        /// Processes a list of files and passes them to the MultiAssetUploader class
        /// Files that come via the browser will not cause sub-categories to be created
        /// unless the file is a zip file in which case the paths in the zip file can be
        /// used to create sub-categories.
        /// </summary>
        /// <param name="filesToUpload">List of filenames to upload</param>
        /// <param name="saveMode">Move or Copy</param>
        /// <param name="IsBrowserUpload">Flag to indicate weather the file came via the browser</param>
        /// <param name="rootPath">The root path for directory scanning</param>
        private void ProcessUpload(IEnumerable <string> filesToUpload, BinaryFile.SaveMode saveMode, bool IsBrowserUpload, string rootPath)
        {
            ErrorList errors = new ErrorList();

            List <UploadedAssetResult> uploadResultList = null;

            rootPath = rootPath.ToLower();

            foreach (string fileName in filesToUpload)
            {
                // At this point we have a list of files containing one or more files to process.
                try
                {
                    // Wrap the uploaded file in a generic BinaryFile class for use in the business layer.
                    BinaryFile file = new BinaryFile(fileName, saveMode);

                    m_Logger.DebugFormat("Uploading file: {0}", file.FileName);

                    // Get the directory name where we're uploading from
                    string relativePath = new FileInfo(fileName).DirectoryName.ToLower();

                    // Strip out the root path if required; we don't need it for processing
                    if (!string.IsNullOrEmpty(relativePath) && !string.IsNullOrEmpty(rootPath))
                    {
                        rootPath = rootPath.Replace(rootPath, string.Empty);
                    }

                    // Initialize the asset uploader
                    MultiAssetUploader assetUploader = new MultiAssetUploader
                    {
                        BinaryFile               = file,
                        SourcePath               = IsBrowserUpload ? string.Empty : relativePath,
                        AssetTypeId              = AssetTypeDropDownList.GetSelectedId(),
                        TargetCategoryId         = CategoryDropDownList.GetSelectedId(),
                        CreateCategorySubFolders = SubFolderCheckBox.Checked,
                        UploadedBy               = CurrentUser,
                        SendEmailOnCompletion    = NotifyWhenProcessedCheckBox.Checked,
                        PreserveZipFile          = PreserveZipFileCheckBox.Checked,
                        DoNotProcessForPreview   = DoNotSubmitForPreviewCheckBox.Checked
                    };

                    assetUploader.BeforeSave += delegate(object aus, AssetEventArgs aue)
                    {
                        aue.Asset.Title             = Path.GetFileNameWithoutExtension(aue.Asset.Filename);
                        aue.Asset.Description       = "No description available";
                        aue.Asset.UsageRestrictions = string.Concat("(c) ", CurrentUser.CompanyName, " ", DateTime.Now.Year);
                    };

                    // Do the upload
                    assetUploader.Upload();

                    m_Logger.DebugFormat("Upload completed successfully");

                    // Get Processed Asset ID's
                    var processedAssetList = from uar in assetUploader.UploadedAssetResultList
                                             where (uar.FileStatus == FileStatus.Processed || (CurrentUser.UserRole == UserRole.SuperAdministrator && uar.FileStatus == FileStatus.DuplicateHash))
                                             select uar.Asset.AssetId.GetValueOrDefault();

                    // Add the assets to the session
                    foreach (int assetId in processedAssetList)
                    {
                        SessionInfo.Current.AdminSessionInfo.UploadedAssetsList.Add(assetId);
                    }

                    // Save the uploaded asset list to the logged in user
                    SiteUtils.SaveUploadedAssetListToCurrentUser();

                    // Toggle panels
                    FormPanel.Visible    = false;
                    SuccessPanel.Visible = true;

                    // Append the asset ID too, so we can jump straight to it
                    if (processedAssetList.LongCount() >= 1)
                    {
                        CatalogueAssetsHyperLink.NavigateUrl += "&AssetId=" + processedAssetList.First();
                    }

                    if (uploadResultList == null)
                    {
                        uploadResultList = assetUploader.UploadedAssetResultList;
                    }
                    else
                    {
                        uploadResultList.AddRange(assetUploader.UploadedAssetResultList);
                    }
                }
                catch (UnauthorizedAccessException uaEx)
                {
                    errors.Add(string.Format("Error uploading asset '{0}', {1}", fileName, uaEx.Message));
                }
                catch (DuplicateHashException dhex)
                {
                    // This exception will only be thrown for single asset uploads.

                    if (EntitySecurityManager.IsAssetRestricted(CurrentUser, dhex.Asset))
                    {
                        IList <Asset> list = new List <Asset> {
                            dhex.Asset
                        };
                        NotifyEngine.AssetUploadDuplicateHash(CurrentUser, list);
                    }

                    errors.Add(string.Format("Error uploading asset '{0}', {1}", fileName, dhex.Message));
                }
                catch (AssetUploadException auex)
                {
                    errors.Add(string.Format("Error uploading asset '{0}', {1}", fileName, auex.Message));
                }
                catch (InvalidAssetException iex)
                {
                    if (iex.Errors.Count > 0)
                    {
                        errors.Add(string.Format("Error uploading asset '{0}'", fileName));
                        errors.AddRange(iex.Errors);
                    }
                    else
                    {
                        errors.Add(string.Format("Error uploading asset '{0}', {1}", fileName, iex.Message));
                    }
                }
                catch (InvalidAssetFileException ifex)
                {
                    errors.Add(string.Format("Error saving asset '{0}', {1}", fileName, ifex.Message));
                }
                catch (ZipException zex)
                {
                    const string message = "An error occured";

                    string error = "It appears that the zip file is corrupt.  Please try re-creating the zip file and uploading again.";

                    if (CurrentUser.UserRole == UserRole.SuperAdministrator)
                    {
                        error += "<br /><br />" + zex;
                    }

                    errors.Add(string.Format("An error ocurred with file '{0}', {1}", fileName, error));
                    ExceptionHandler.HandleException(zex, message);
                }
                catch (Exception ex)
                {
                    const string message = "Unknown error occured when uploading asset(s)";
                    string       error   = (CurrentUser.UserRole == UserRole.SuperAdministrator) ? ex.ToString() : ex.Message;

                    errors.Add(string.Format("Unknown error occured when uploading asset '{0}', {1}", fileName, error));
                    ExceptionHandler.HandleException(ex, message);
                }
            }

            // Display errors if we have any
            if (errors.Count > 0)
            {
                MessageLabel1.SetErrorMessage("Errors occurred while uploading assets", errors);
            }

            if (uploadResultList != null && uploadResultList.Count > 0)
            {
                // Get the groups of files
                var statusList = (from result in uploadResultList
                                  select result.FileStatus).Distinct();

                // Sort the groups, push processed group to the top as this is the most important
                var sortedStatusList = from status in statusList
                                       let SortOrder = (status == FileStatus.Processed) ? 1 : 0
                                                       orderby SortOrder
                                                       select status;

                // Populate the groups with files
                var fileGroupList = from status in sortedStatusList
                                    select new FileGroup(status, from result in uploadResultList
                                                         where (result.FileStatus == status)
                                                         orderby result.Filename
                                                         select result.Filename);

                // Notify admins about any assets uploaded that were duplicates of an
                // existing asset and the upload user does not have access to that asset.
                var duplicateAssets = from result in uploadResultList
                                      where (result.FileStatus == FileStatus.DuplicateHash) && (EntitySecurityManager.IsAssetRestricted(CurrentUser, result.Asset))
                                      orderby result.Asset.AssetId
                                      select result.Asset;

                // Send the notification
                if (duplicateAssets.LongCount() > 0)
                {
                    NotifyEngine.AssetUploadDuplicateHash(CurrentUser, duplicateAssets);
                }

                // Bind the list
                UploadedFileListRepeater.DataSource = fileGroupList;
                UploadedFileListRepeater.DataBind();
            }
        }