--- title: "Uploading Additional Data in ActiveX/Java Uploader ASP.NET" canonical: https://www.aurigma.com/docs/us8/uploading-additional-data-in-aspnet-iu.htm product: "Upload Suite 8" --- # Uploading Additional Data in ActiveX/Java Uploader ASP.NET Pretty often it is necessary to send additional information along with files. ActiveX/Java Uploader comprehensively solves this task and supports uploading the following kinds of additional information: - a common information about upload defined by the Web site logic, such as an author name, keywords, or a category caption - a simple text description - a hidden tag - image crop bounds and rotation angle - more image-specific information, like copyright notes and camera parameters during capturing, contained in EXIF and IPTC fields - hash sums This topic has three paragraphs, namely, uploading common data, uploading image-specific data and hash sums. Each of them describes approaches on how to send and receive relevant data, possibilities provided by these approaches, and code samples. **Note** If you are unfamiliar with the [Saving Uploaded Files in ActiveX/Java Uploader ASP.NET](https://www.aurigma.com/docs/us8/saving-uploaded-files-in-aspnet-iu.htm.md) topic, please, read it first. ## Uploading Common Data This section describes several approaches to uploading additional data. They are quite different but have two features in common, namely, independence of file types and upload of common data. - To get user-provided information about a whole upload you may use an HTML form, as described in the using additional HTML form section. This approach is simple to use and understand, it is also quite flexible. Pay attention to the fact that in this case you cannot upload different data for different files, only one set of data for a whole upload. - To add hidden data to a whole upload you can use custom fields. As opposed to the previous method, this one allows you to add data programmatically. For more information about this approach, see the using additional field section. - To upload user-defined file descriptions you do not need to configure ActiveX/Java Uploader beforehand, so it is the simplest way to get additional information with each uploaded file. Receiving of descriptions is examined in the using descriptions section. - To send a hidden piece of data for each user-selected file you may use tags. This approach is described in the using tags section. - To add elementary information to upload you can pass additional data as arguments like it is usually done in GET requests, this approach is described in the using query string section. ### Using Additional HTML Form Using HTML forms is the most straight-forward way to upload data in web applications, thus, ActiveX/Java Uploader supports it. All you need is just to add the desired form to the same page where the [Uploader](https://www.aurigma.com/docs/us8/JA_T_Aurigma_ImageUploader_Uploader.htm.md) control is hosted and set the [Metadata.AdditionalFormName](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_Metadata_AdditionalFormName.htm.md) property to the name of created form. Then, when a user clicks **Upload**, the form data will be submitted along with user-selected files. On the server side, the fields of this form are accessible through the [Package.PackageFields](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_Package_PackageFields.htm.md) collection by their names. An additional form can contain HTML input elements of different types, for example, you may use: - `text` for an author name - `checkbox` to determine whether to send a notification about the upload completion - `select` to choose keywords related to the upload **Note** The following input types are not allowed: `file`, `image`, `button`, and `reset`. Their values will not be sent at all. #### Sending Data The following configuration makes ActiveX/Java Uploader sending data from the `addForm` form along with uploaded files. ```aspx-cs
``` #### Receiving Sent Data Fields of the additional form are sent in each package, though in the following example we use the first package, which number is `0`, because there is always at least one package in the upload session. ```csharp protected void AllFilesUploaded(object sender, Aurigma.ImageUploader.AllFilesUploadedEventArgs e) { string keywords = e.Packages[0].PackageFields["keywords"]; string addressee = e.Packages[0].PackageFields["addressee"]; } ``` ### Using Additional Field Additional fields can be attached to the POST request using the [metadata.addCustomField(String, String, Boolean)](https://www.aurigma.com/docs/us8/JA_M_J_$au_metadata_addCustomField_3_c43e5881.htm.md) method. It accepts the following parameters: 1. name of the additional field 2. value of the additional field 3. optional parameter telling how to deal with previous value of this field, which is overwritten by default You may add custom fields to the upload request only at runtime using the [ActiveX/Java Uploader JavaScript API](https://www.aurigma.com/docs/us8/using-javascript-api.htm.md). Custom fields can use any format you like but should not conflict with the standard field names. See the [POST Field Reference](https://www.aurigma.com/docs/us8/post-field-reference-iu.htm.md) topic for a full list of standard ActiveX/Java Uploader fields. On the server side, additional fields are accessible through the **Package.PackageFields** collection by their names. The following example sends and receives an additional field named `authorField`. Here the **metadata.addCustomField(String, String, Boolean)** method is called in the [BeforeUpload](https://www.aurigma.com/docs/us8/JA_E_Uploader_BeforeUpload.htm.md) event handler, which fires when the upload is about to be started. For more information about events, please, see the [using events](https://www.aurigma.com/docs/us8/using-javascript-api.htm.md) section. #### Sending Data ```aspx-cs
``` #### Receiving Sent Data Additional fields are sent in each package, though in the following example we use the first package, which number is `0`, because there is always at least one package in the upload session. ```csharp protected void AllFilesUploaded(object sender, Aurigma.ImageUploader.AllFilesUploadedEventArgs e) { string author = e.Packages[0].PackageFields["authorField"]; } ``` ### Receiving Descriptions Each file uploaded via ActiveX/Java Uploader may have a description. There is no need to turn this possibility on, because it is enabled by default. So, let us examine how to get descriptions of uploaded files on a server using the FileUploaded [Uploader.FileUploaded](https://www.aurigma.com/docs/us8/JA_E_Aurigma_ImageUploader_BaseUploadControl_FileUploaded.htm.md) [UploadRequest.FileUploaded](https://www.aurigma.com/docs/us8/JA_E_Aurigma_ImageUploader_UploadRequest_FileUploaded.htm.md) [UploadHandler.FileUploaded](https://www.aurigma.com/docs/us8/JA_E_Aurigma_ImageUploader_UploadHandler_FileUploaded.htm.md) event handler: ```csharp protected void FileUploaded(object sender, Aurigma.ImageUploader.FileUploadedEventArgs e) { string description = e.UploadedFile.Description; } ``` ### Using Tags Tags give you an opportunity to send a hidden piece of data with each user-selected file. To attach such data use the [file.tag](https://www.aurigma.com/docs/us8/JA_P_J_$au_file_tag.htm.md) property as it is demonstrated in the sample below. You may set tags only at runtime using the [ActiveX/Java Uploader JavaScript API](https://www.aurigma.com/docs/us8/using-javascript-api.htm.md). On the server side you may get a tag through the [UploadedFile.Tag](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_UploadedFile_Tag.htm.md) property. The following example sends and receives tags for all selected files. Here the **file.tag** property is specified in the **BeforeUpload** event handler, which fires when the upload is about to be started. For more information about events, please, see the [using events](https://www.aurigma.com/docs/us8/using-javascript-api.htm.md) section. #### Sending Data ```aspx-cs
``` #### Receiving Sent Data ```csharp protected void FileUploaded(object sender, Aurigma.ImageUploader.FileUploadedEventArgs e) { string tag = e.UploadedFile.Tag; } ``` ### Using Query String To pass data via the query string, just add necessary arguments to the upload script URL ([UploadSettings.ActionUrl](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_UploadSettings_ActionUrl.htm.md)) and parse the request on a server as it is shown in the example below. #### Sending Data ```aspx-cs ``` #### Receiving Sent Data ```csharp protected void Page_Load(object sender, EventArgs e) { if (System.String.Equals(Request.RequestType, "POST")) { string arg1 = Request["argument1"]; string arg2 = Request["argument2"]; } } ``` ## Uploading Image-specific Data ActiveX/Java Uploader has some imaging capabilities, which are described in the [Working with Images](https://www.aurigma.com/docs/us8/working-with-images.htm.md) topic and [Uploading Images](https://www.aurigma.com/docs/us8/uploading-images-iu.htm.md) section. Let us describe two of these features, which allow uploading additional data: 1. [Rotating and Cropping via ActiveX/Java Uploader](https://www.aurigma.com/docs/us8/rotating-and-cropping-iu.htm.md) of images are enabled in ActiveX/Java Uploader by default. So, it is a good idea to get rotation angle and crop bounds on a server. To get more information on how to do this, see the receiving rotation angle and crop bounds section. 2. [Working with EXIF and IPTC Metadata in ActiveX/Java Uploader](https://www.aurigma.com/docs/us8/working-with-exif-and-iptc-metadata-iu.htm.md) provides, among other possibilities, an opportunity to extract and upload EXIF and IPTC fields for each user-selected image. EXIF metadata is a special information about the image, written into the file by the capturing device when an image was captured. These metadata may provide camera parameters during capturing, date and time of the capturing, photographer's name, and etc. IPTC is another metadata format, which is widely used in journalism to keep information about a photo, like byline, subject, location, and etc. See the handling EXIF and IPTC metadata section for detailed description on how to send and receive such metadata. ### Receiving Rotation Angle and Crop Bounds A rotation angle and crop bounds can be got through the [Angle](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_UploadedFile_Angle.htm.md) and [CropBounds](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_UploadedFile_CropBounds.htm.md) properties of the [UploadedFile](https://www.aurigma.com/docs/us8/JA_T_Aurigma_ImageUploader_UploadedFile.htm.md) class respectively. ActiveX/Java Uploader measures rotation angle in degrees clockwise. As soon as rotation and cropping of images are allowed by default, there is no need to configure ActiveX/Java Uploader to send them, so the following example shows only how to receive such data on a server. ```csharp protected void FileUploaded(object sender, Aurigma.ImageUploader.FileUploadedEventArgs e) { int angle = e.UploadedFile.Angle; Rectangle cropBounds = e.UploadedFile.CropBounds; } ``` ### Handling EXIF and IPTC Metadata To upload EXIF or IPTC values, you should specify the desired fields using the [Metadata.Exif](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_Metadata_Exif.htm.md) and [Metadata.Iptc](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_Metadata_Iptc.htm.md) properties. Both these properties represent semicolon separated lists of field names which should be extracted and uploaded along with images. To specify a custom EXIF tag, for example, Windows image title, use the hexadecimal ID of the tag. [Metadata.ValueSeparator](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_Metadata_ValueSeparator.htm.md) sets a string separator for fields which can contain multiple string values, like **IptcKeyword**. #### Sending Data The following example sends two EXIF and two IPTC fields for each user-selected image: ```aspx-cs <%--here 0x9c9b is the hexadecimal ID of the windows image title tag--%> ``` #### Receiving Sent Data The following example gets the EXIF and IPTC fields sent accordingly to the previous configuration and writes these values to the ` Descriptions.xml` file. Here uploaded fields are contained in the **Package.PackageFields** collection and can be retrieved by keys named in the following way: `FieldName_xx`, where `FieldName` is a name of an EXIF or IPTC field and `xx` is the index of an uploaded file in this package. To get access to a custom EXIF tag use the `ExifCustom_ID_xx` keys, where `ID` is tag's hexadecimal ID. ```csharp protected void FileUploaded(object sender, Aurigma.ImageUploader.FileUploadedEventArgs e) { string galleryPath = Server.MapPath("Gallery"); System.Xml.XmlDocument descriptions = new System.Xml.XmlDocument(); if (System.IO.File.Exists(galleryPath + "Descriptions.xml")) descriptions.Load(galleryPath + "Descriptions.xml"); else descriptions.AppendChild(descriptions.CreateElement("files")); System.Xml.XmlElement file = descriptions.CreateElement("file"); file.SetAttribute("name", e.UploadedFile.SourceName); file.SetAttribute("CopyrightNotice", e.UploadedFile.Package.PackageFields["IptcCopyrightNotice_" + e.UploadedFile.Index]); file.SetAttribute("IptcKeyword", e.UploadedFile.Package.PackageFields["IptcKeyword_" + e.UploadedFile.Index]); file.SetAttribute("ExifColorSpace", e.UploadedFile.Package.PackageFields["ExifColorSpace_" + e.UploadedFile.Index]); file.SetAttribute("ExifDateTime", e.UploadedFile.Package.PackageFields["ExifDateTime_" + e.UploadedFile.Index]); //here 9C9B is the hexadecimal ID of the windows image title tag file.SetAttribute("Windows title", e.UploadedFile.Package.PackageFields["ExifCustom_9C9B_" + e.UploadedFile.Index]); descriptions.DocumentElement.AppendChild(file); descriptions.Save(galleryPath + "Descriptions.xml"); } ``` **Note** All date/time values have the following format: `YYYY:MM:DD hh:mm:ss`. For example, May 11, 2006, 2:40PM would be represented as: `2006:05:11 14:40:00`. ## Using Hash Sums **Note** ActiveX/Java Uploader Express does not support creating hash sums for files. See the [Upload Suite Editions](https://www.aurigma.com/docs/us8/upload-suite-editions.htm.md) topic for details. File hash sum uniqely identifies a file; it is useful for accomplishing two main tasks: to check uploaded files integrity and to prevent duplicate file upload. ActiveX/Java Uploader provides the [Converter.Hash](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_Converter_Hash.htm.md) and [Metadata.Hash](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_Metadata_Hash.htm.md) properties to enable hash sums. The **Converter.Hash** property is used to enable hash values for checking upload integrity. If you use this property, ActiveX/Java Uploader will send hash value for a converted file along with the file. The **Metadata.Hash** property allows sending hash sums without sending files; it is useful to prevent duplicate files upload. On the server side uploaded hash sums are accessible through the **Package.PackageFields** collection. ActiveX/Java Uploader encodes hash values using the Base64 algorithm; make sure that the server-side script uses the same algorithm. To send several hash values (calculated using different algorithms) specify the semicolon-separated list of algorithms as a property value. ### Checking Upload Integrity Checking upload integrity works in the following way: 1. You set one or several hash algorithms using the **Converter.Hash** property. 2. Before the upload process begins, ActiveX/Java Uploader calculates the hash value (or several values) according to settings specified on the first step. 3. Base64-encoded hash values are appended to the request. 4. The server-side code calculates hash values for received files using the algorithm specified on the first step and compares values with the ones received from the client side. 5. If hash values are the same, the verification is successful. Otherwise, the upload is corrupted. On the server side you can receive hash values using the following field name: `FileNAlgorithmName_xx`, where `AlgorithmName` is the name of hash algorithm (SHA, MD2, or MD5), `N` is a zero-based index of the converter, and `xx` is the index of an uploaded file in a package. In the following two-part example ActiveX/Java Uploader sends an MD5 hash sum for each created thumbnail. The server-side script in the second part calculates MD5 hash value for received thumbnail, compares it with the uploaded sum, and saves the file if both hash sums are identical, which means that upload is successful. #### Sending Data ```aspx-cs ``` #### Receiving Sent Data ```csharp protected void FileUploaded(object sender, Aurigma.ImageUploader.FileUploadedEventArgs e) { Aurigma.ImageUploader.ConvertedFile sourceFile = e.UploadedFile.ConvertedFiles[0]; System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider(); string actualMd5 = Convert.ToBase64String(md5.ComputeHash(sourceFile.FileStream), Base64FormattingOptions.InsertLineBreaks); string receivedMd5 = e.UploadedFile.Package.PackageFields["File0MD5_" + e.UploadedFile.Index]; if (string.Equals(actualMd5, receivedMd5)) { sourceFile.SaveAs(System.IO.Path.Combine(Server.MapPath("Gallery"), sourceFile.Name)); } } ``` ### Preventing Duplicate File Upload Using the **Metadata.Hash** property you can detect duplicate files before they are uploaded to the server. The idea is to upload hash values for all user-selected files on the first step, then check whether these files have already been uploaded to the Web server in the past or not, and upload only the files not exisitng on the server. In general, the following actions should be implemented: 1. You configure ActiveX/Java Uploader to send hash values without sending the files: use the **Metadata.Hash** property to specify desired hash algorithm and set the [Converter.Mode](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_Converter_Mode.htm.md) property to `"*.*=None"`. 2. After upload starts, ActiveX/Java Uploader uploads hash values. 3. Server script checks for duplicates by comparing newly uploaded hash values with the ones already stored on the server. 4. If there are duplicates, server script sends a response containing list of duplicate files. 5. The [Uploader.AfterUpload](https://www.aurigma.com/docs/us8/JA_E_Uploader_AfterUpload.htm.md) event handler deletes duplicate files from the upload list and initiates files upload process (by calling the [uploader.upload()](https://www.aurigma.com/docs/us8/JA_M_J_$au_uploader_upload.htm.md) method). 6. The BeforeUpload event handler sets the **Converter.Mode** property to `"*.*=SourceFile"` to enable sending original files. 7. ActiveX/Java Uploader sends unique files to the server. **Note** You can detect duplicates of original files only; not thumbnails. On the server side you can receive hash values using the following field name: `HashCodeAlgorithmName_xx`, where `AlgorithmName` is one of the following algorithms: SHA, MD2, or MD5 and `xx` is the index of an uploaded file in a package. The following two-part example illustrates this approach. The first part configures ActiveX/Java Uploader, controls upload process, and deletes duplicate files from upload list (if any). The server-side script in the second part compares received hash values with the stored ones, sends back list of duplicate files (if any), and saves uploaded files and their hash values to file system. The example stores hash values in XML file solely for brevity; in a real-life application most likely you will use database instead. #### Sending Data ```aspx-cs
``` #### Receiving Sent Data ```csharp private List hashes = new List(); private List existedFiles = new List(); protected void AllFilesUploaded(object sender, AllFilesUploadedEventArgs e) { string galleryPath = Server.MapPath("Gallery"); System.Xml.XmlDocument descriptions = new System.Xml.XmlDocument(); if (System.IO.File.Exists(Path.Combine(galleryPath, "Descriptions.xml"))) descriptions.Load(Path.Combine(galleryPath, "Descriptions.xml")); else descriptions.AppendChild(descriptions.CreateElement("files")); if (!string.IsNullOrEmpty(Request["hashcheck"])) { //read all hash sums from Descriptions.xml hashes.Clear(); System.Xml.XmlNodeList hashSums = descriptions.SelectNodes("/files/file[@md5]/@md5"); for (int i = 0; i < hashSums.Count; i++) { System.Xml.XmlNode hashSum = hashSums[i]; hashes.Add(hashSum.Value.ToString()); } //check for equal hash sums foreach (UploadedFile uploadedFile in e.UploadedFiles) { string hash = uploadedFile.Package.PackageFields["HashCodeMD5_" + uploadedFile.Index]; if (hashes.Contains(hash)) existedFiles.Add(uploadedFile.Index.ToString()); } Response.ClearContent(); Response.Write(string.Join(";", existedFiles.ToArray())); Response.End(); } foreach (UploadedFile uploadedFile in e.UploadedFiles) { // Get source file ConvertedFile sourceFile = uploadedFile.ConvertedFiles[0]; if (sourceFile != null) { // Save file to the disk sourceFile.SaveAs(Path.Combine(galleryPath, uploadedFile.SourceName)); //Add file hash sums to the Descriptions.xml file System.Xml.XmlElement file = descriptions.CreateElement("file"); file.SetAttribute("name", uploadedFile.SourceName); file.SetAttribute("md5", uploadedFile.Package.PackageFields["HashCodeMD5_" + uploadedFile.Index]); descriptions.DocumentElement.AppendChild(file); descriptions.Save(Path.Combine(galleryPath, "Descriptions.xml")); } } } ``` ## See Also ### Reference - [Metadata Class](https://www.aurigma.com/docs/us8/JA_T_Aurigma_ImageUploader_Metadata.htm.md) - [Package Class](https://www.aurigma.com/docs/us8/JA_T_Aurigma_ImageUploader_Package.htm.md) - [addCustomField(String, String, Boolean) Method](https://www.aurigma.com/docs/us8/JA_M_J_$au_metadata_addCustomField_3_c43e5881.htm.md) - [tag Property](https://www.aurigma.com/docs/us8/JA_P_J_$au_file_tag.htm.md) - [UploadedFile Class](https://www.aurigma.com/docs/us8/JA_T_Aurigma_ImageUploader_UploadedFile.htm.md) - FileUploaded [Uploader.FileUploaded](https://www.aurigma.com/docs/us8/JA_E_Aurigma_ImageUploader_BaseUploadControl_FileUploaded.htm.md) [UploadRequest.FileUploaded](https://www.aurigma.com/docs/us8/JA_E_Aurigma_ImageUploader_UploadRequest_FileUploaded.htm.md) [UploadHandler.FileUploaded](https://www.aurigma.com/docs/us8/JA_E_Aurigma_ImageUploader_UploadHandler_FileUploaded.htm.md) - AllFilesUploaded [Uploader.AllFilesUploaded](https://www.aurigma.com/docs/us8/JA_E_Aurigma_ImageUploader_BaseUploadControl_AllFilesUploaded.htm.md) [UploadRequest.AllFilesUploaded](https://www.aurigma.com/docs/us8/JA_E_Aurigma_ImageUploader_UploadRequest_AllFilesUploaded.htm.md) [UploadHandler.AllFilesUploaded](https://www.aurigma.com/docs/us8/JA_E_Aurigma_ImageUploader_UploadHandler_AllFilesUploaded.htm.md) - [BeforeUpload Event](https://www.aurigma.com/docs/us8/JA_E_Uploader_BeforeUpload.htm.md) - [ActionUrl Property](https://www.aurigma.com/docs/us8/JA_P_Aurigma_ImageUploader_UploadSettings_ActionUrl.htm.md) - [upload() Method](https://www.aurigma.com/docs/us8/JA_M_J_$au_uploader_upload.htm.md) ### Manual - [Saving Uploaded Files in ActiveX/Java Uploader ASP.NET](https://www.aurigma.com/docs/us8/saving-uploaded-files-in-aspnet-iu.htm.md) - [Configuring POST Format](https://www.aurigma.com/docs/us8/configuring-post-format.htm.md) - [Using JavaScript API](https://www.aurigma.com/docs/us8/using-javascript-api.htm.md) - [Rotating and Cropping via ActiveX/Java Uploader](https://www.aurigma.com/docs/us8/rotating-and-cropping-iu.htm.md) - [Working with EXIF and IPTC Metadata in ActiveX/Java Uploader](https://www.aurigma.com/docs/us8/working-with-exif-and-iptc-metadata-iu.htm.md) - [Working with Images](https://www.aurigma.com/docs/us8/working-with-images.htm.md)