@openui5/sap.m 1.115.1 → 1.116.0

package/src/sap/m/upload/UploadSetTableItem.js

@@ -0,0 +1,327 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+// Provides control sap.m.upload.UploadSetTableItem.
+sap.ui.define([
+	"sap/m/ColumnListItem",
+	"sap/ui/core/IconPool",
+	"sap/m/upload/UploadSetTableItemRenderer",
+	"sap/base/Log",
+	"sap/m/upload/FilePreviewDialog"
+], function (ColumnListItem, IconPool, UploadSetTableItemRenderer, Log, FilePreviewDialog) {
+    "use strict";
+
+	/**
+	 * Constructor for a new UploadSetTableItem.
+	 *
+	 * @param {string} [sId] ID for the new control, will be generated automatically if no ID is provided.
+	 * @param {object} [mSettings] Initial settings for the new control.
+	 * @class ColumnListItem that represents one item to be uploaded using the {@link sap.m.upload.UploadSetTable} control.
+	 * @extends sap.m.ColumnListItem
+	 * @author SAP SE
+	 * @constructor
+	 * @private
+	 * @experimental
+	 * @internal
+	 * @alias sap.m.upload.UploadSetTableItem
+	 */
+    var UploadSetTableItem = ColumnListItem.extend("sap.m.upload.UploadSetTableItem", {
+        metadata: {
+            properties: {
+                /**
+				 * Specifies the name of the uploaded file.
+				 */
+				fileName: {type: "string", defaultValue: null},
+				/**
+				 * Specifies the MIME type of the file.
+				 */
+                mediaType: {type: "string", defaultValue: null},
+				/**
+				 * Specifies the URL where the file is located.
+				 */
+				url: {type: "string", defaultValue: null},
+				/**
+				 * URL where the uploaded files will be stored. If empty, uploadUrl from the uploader is considered.
+				 */
+				uploadUrl: {type: "string", defaultValue: null},
+		        /**
+				 * State of the item relevant to its upload process.
+				 */
+				uploadState: {type: "sap.m.UploadState", defaultValue: null}
+            },
+			aggregations: {
+				/**
+				 * Header fields to be included in the header section of an XMLHttpRequest (XHR) request
+				 */
+				headerFields: {type: "sap.ui.core.Item", multiple: true, singularName: "headerField"}
+			}
+        },
+		render: UploadSetTableItemRenderer
+    });
+
+	/* ================== */
+	/* Lifecycle handling */
+	/* ================== */
+
+    UploadSetTableItem.prototype.init = function () {
+        ColumnListItem.prototype.init.apply(this, arguments);
+		this._oFileObject = null;
+		this._fFileSize = null;
+		// Restriction flags
+		this._bFileTypeRestricted = false;
+		this._bNameLengthRestricted = false;
+		this._bSizeRestricted = false;
+		this._bMediaTypeRestricted = false;
+    };
+
+    UploadSetTableItem.prototype.onBeforeRendering = function () {
+        ColumnListItem.prototype.onBeforeRendering.apply(this, arguments);
+    };
+
+	UploadSetTableItem.prototype.onAfterRendering = function() {
+		ColumnListItem.prototype.onAfterRendering.call(this);
+	};
+
+	UploadSetTableItem.prototype.exit = function() {
+		ColumnListItem.prototype.exit.call(this);
+	};
+
+	/* ===================== */
+	/* Overriden API methods */
+	/* ===================== */
+
+	UploadSetTableItem.prototype.setFileName = function (sFileName) {
+		if (this.getFileName() !== sFileName) {
+			this.setProperty("fileName", sFileName, true);
+			// File name related controls available no sooner than a parent is set
+			if (this.getParent()) {
+				this._checkNameLengthRestriction(this.getParent().getMaxFileNameLength());
+				this._checkTypeRestriction(this.getParent().getFileTypes());
+			}
+		}
+
+		return this;
+	};
+
+	/* ============== */
+	/* Public methods */
+	/* ============== */
+
+	/**
+	 * Returns file object.
+	 *
+	 * @public
+	 * @returns {File|Blob} File object.
+	 *
+	 */
+	UploadSetTableItem.prototype.getFileObject = function () {
+		return this._oFileObject;
+	};
+
+	/**
+	 * Previews pressed file.
+	 * @param {sap.m.upload.UploadSetTableItem} oItem The pressed UploadSetTableItem.
+	 * @public
+	 */
+	UploadSetTableItem.openPreview = function (oItem) {
+		oItem._previewCarousel();
+	};
+
+	/**
+	 * Downloads the item. Only possible when the item has a valid URL specified in the <code>url</code> property.
+	 * @param {boolean} bAskForLocation Whether to ask for a location where to download the file or not.
+	 * @public
+	 * @returns {boolean} <code>true</code> if download is possible, <code>false</code> otherwise.
+	 */
+	UploadSetTableItem.prototype.download = function (bAskForLocation) {
+		var oParent = this.getParent();
+		if (!oParent) {
+			Log.warning("Download cannot proceed without a parent association.");
+			return false;
+		}
+
+		return oParent._getActiveUploader ? oParent._getActiveUploader().download(this, [], bAskForLocation) : false;
+	};
+
+	/**
+	 * Validates if the item is restricted, which means that it is restricted for the file type, media type, maximum file name length and maximum file size limit.
+	 *
+	 * @public
+	 * @since 1.98
+	 * @returns {boolean} <code>true</code> if item is restricted, <code>false</code> otherwise.
+	 *
+	 */
+	UploadSetTableItem.prototype.isRestricted = function () {
+		return this._isRestricted();
+	};
+
+	/* =============== */
+	/* Private methods */
+	/* =============== */
+
+	/**
+	 * Previews file in a dialog with carousel.
+	 */
+	UploadSetTableItem.prototype._previewCarousel = function () {
+		var filePreviewDialog = new FilePreviewDialog(this);
+		filePreviewDialog.open();
+	};
+
+	UploadSetTableItem._getIconByMimeType = function(sMimeType, fileName) {
+
+		var mimeTypeForImages = ["image/png", "image/tiff", "image/bmp", "image/jpeg", "image/gif"];
+
+		if (sMimeType) {
+			if (mimeTypeForImages.indexOf(sMimeType) === -1) {
+				return IconPool.getIconForMimeType(sMimeType);
+			}
+			return UploadSetTableItem._getIconByFileType(fileName);
+		} else {
+			return UploadSetTableItem._getIconByFileType(fileName);
+		}
+	};
+
+	UploadSetTableItem._getIconByFileType = function (fileName) {
+		var sFileExtension = UploadSetTableItem._splitFileName(fileName).extension;
+		if (!sFileExtension) {
+			return "sap-icon://document";
+		}
+
+		switch (sFileExtension.toLowerCase()) {
+			case "bmp" :
+			case "jpg" :
+			case "jpeg" :
+			case "png" :
+				return UploadSetTableItem.IMAGE_FILE_ICON;
+			case "csv" :
+			case "xls" :
+			case "xlsx" :
+				return "sap-icon://excel-attachment";
+			case "doc" :
+			case "docx" :
+			case "odt" :
+				return "sap-icon://doc-attachment";
+			case "pdf" :
+				return "sap-icon://pdf-attachment";
+			case "ppt" :
+			case "pptx" :
+				return "sap-icon://ppt-attachment";
+			case "txt" :
+				return "sap-icon://document-text";
+			default :
+				return "sap-icon://document";
+		}
+	};
+
+	UploadSetTableItem._splitFileName = function (sFileName, bWithDot) {
+		var oResult = {};
+		var oRegex = /(?:\.([^.]+))?$/;
+		var aFileExtension = oRegex.exec(sFileName);
+		if (!aFileExtension[0]) {
+			aFileExtension[0] = "";
+			oResult.name = sFileName;
+		} else {
+			oResult.name = sFileName ? sFileName.slice(0, sFileName.indexOf(aFileExtension[0])) : "";
+		}
+		if (bWithDot) {
+			oResult.extension = aFileExtension[0];
+		} else {
+			oResult.extension = aFileExtension[1];
+		}
+		return oResult;
+	};
+
+	UploadSetTableItem.prototype._setFileObject = function (oFileObject) {
+		this._oFileObject = oFileObject;
+		if (oFileObject) {
+			this._fFileSize = oFileObject.size / UploadSetTableItem.MEGABYTE;
+			this.setMediaType(oFileObject.type);
+		} else {
+			this._fFileSize = null;
+			this.setMediaType(null);
+		}
+		if (this.getParent()) {
+			this._checkSizeRestriction(this.getParent().getMaxFileSize());
+			this._checkMediaTypeRestriction(this.getParent().getMediaTypes());
+		}
+	};
+
+	/**
+	 * Checks if and how compliance with the file name length restriction changed for this item.
+	 * @param {int} iMaxLength Maximum length of file name.
+	 * @private
+	 */
+	UploadSetTableItem.prototype._checkNameLengthRestriction = function (iMaxLength) {
+		var bRestricted = (iMaxLength && !!this.getFileName() && this.getFileName().length > iMaxLength);
+		if (bRestricted !== this._bNameLengthRestricted) {
+			this._bNameLengthRestricted = bRestricted;
+			this.invalidate();
+			if (bRestricted && this.getParent()) {
+				this.getParent().fireFileNameLengthExceeded({item: this});
+			}
+		}
+	};
+
+	/**
+	 * Checks if and how compliance with the file size restriction changed for this item.
+	 * @param {float} fMaxSize Maximum file size allowed in megabytes.
+	 * @private
+	 */
+	UploadSetTableItem.prototype._checkSizeRestriction = function (fMaxSize) {
+		var bRestricted = (fMaxSize && this._fFileSize > fMaxSize);
+		if (bRestricted !== this._bSizeRestricted) {
+			this._bSizeRestricted = bRestricted;
+			this.invalidate();
+			if (bRestricted && this.getParent()) {
+				this.getParent().fireFileSizeExceeded({item: this});
+			}
+		}
+	};
+
+	/**
+	 * Checks if and how compliance with the mime type restriction changed for this item.
+	 * @param {string[]} aTypes List of allowed mime types.
+	 * @private
+	 */
+	UploadSetTableItem.prototype._checkMediaTypeRestriction = function (aTypes) {
+		var bRestricted = (!!aTypes && (aTypes.length > 0) && !!this.getMediaType() && aTypes.indexOf(this.getMediaType()) === -1);
+		if (bRestricted !== this._bMediaTypeRestricted) {
+			this._bMediaTypeRestricted = bRestricted;
+			this.invalidate();
+			if (bRestricted && this.getParent()) {
+				this.getParent().fireMediaTypeMismatch({item: this});
+			}
+		}
+	};
+
+	/**
+	 * Checks if and how compliance with the file type restriction changed for this item.
+	 * @param {string[]} aTypes List of allowed file types.
+	 * @private
+	 */
+	UploadSetTableItem.prototype._checkTypeRestriction = function (aTypes) {
+		var oFile = UploadSetTableItem._splitFileName(this.getFileName()),
+			bRestricted =
+				(!!this.getFileName() && !!aTypes && (aTypes.length > 0)
+					&& oFile.extension && aTypes.indexOf(oFile.extension.toLowerCase()) === -1);
+		if (bRestricted !== this._bFileTypeRestricted) {
+			this._bFileTypeRestricted = bRestricted;
+			this.invalidate();
+			if (bRestricted && this.getParent()) {
+				this.getParent().fireFileTypeMismatch({item: this});
+			}
+		}
+	};
+
+	UploadSetTableItem.prototype._isRestricted = function () {
+		return this._bFileTypeRestricted || this._bNameLengthRestricted || this._bSizeRestricted || this._bMediaTypeRestricted;
+	};
+
+    UploadSetTableItem.IMAGE_FILE_ICON = "sap-icon://card";
+	UploadSetTableItem.MEGABYTE = 1048576;
+
+    return UploadSetTableItem;
+});

package/src/sap/m/upload/UploadSetTableItemRenderer.js

@@ -0,0 +1,22 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+sap.ui.define(["sap/ui/core/Renderer", "sap/m/ColumnListItemRenderer", "sap/m/ListItemBaseRenderer"], function (Renderer, ColumnListItemRenderer) {
+	"use strict";
+
+	/**
+	 * UploadSetTableItem renderer.
+	 * @namespace
+	 */
+	var UploadSetTableItemRenderer = Renderer.extend(ColumnListItemRenderer);
+	UploadSetTableItemRenderer.apiVersion = 2;
+
+    UploadSetTableItemRenderer.render = function(rm, oLI) {
+		ColumnListItemRenderer.render.apply(this, arguments);
+	};
+    // enable in-place DOM patching
+	return UploadSetTableItemRenderer;
+}, /* bExport= */ true);

package/src/sap/m/upload/UploadSetTableRenderer.js

@@ -0,0 +1,34 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+sap.ui.define(["sap/ui/core/Renderer", "sap/m/TableRenderer", "sap/m/Table"
+], function (Renderer, TableRenderer, Table) {
+	"use strict";
+
+	/**
+	 * UploadSetTable renderer.
+	 * @namespace
+	 */
+	var UploadSetTableRenderer = Renderer.extend(TableRenderer);
+	UploadSetTableRenderer.apiVersion = 2; // enable in-place DOM patching
+
+
+	/**
+	 * Renders the HTML for the given control, using the provided {@link sap.ui.core.RenderManager}.
+	 *
+	 * @param {sap.ui.core.RenderManager} oRm the RenderManager that can be used for writing to the render output buffer.
+	 * @param {sap.m.upload.UploadSetTable} oControl an object representation of the control that should be rendered.
+	 */
+	UploadSetTableRenderer.render = function (oRm, oControl) {
+		oRm.openStart("div",oControl);
+		oRm.class("sapMUST");
+		oRm.openEnd();
+		TableRenderer.render.apply(this,arguments);
+		oRm.close("div");
+	};
+
+	return UploadSetTableRenderer;
+});

package/src/sap/m/upload/UploadSetToolbarPlaceholder.js

@@ -22,7 +22,7 @@ sap.ui.define([
 	 * @extends sap.ui.core.Control
 	 *
 	 * @author SAP SE
-	 * @version 1.115.1
+	 * @version 1.116.0
 	 *
 	 * @constructor
 	 * @public

package/src/sap/m/upload/UploaderTableItem.js

@@ -0,0 +1,276 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+sap.ui.define([
+	"sap/base/Log",
+	"sap/m/library",
+	"sap/ui/core/Element",
+	"sap/ui/core/util/File",
+	"sap/ui/Device",
+	"sap/m/upload/UploadSetTableItem",
+	"sap/m/upload/UploaderHttpRequestMethod"
+], function (Log, MobileLibrary, Element, FileUtil, Device, UploadSetItem, UploaderHttpRequestMethod) {
+	"use strict";
+
+	/**
+	 * Constructor for a new Uploader.
+	 *
+	 * @class
+	 * A basic implementation for uploading and downloading one or multiple files.
+	 *
+	 * @extends sap.ui.core.Element
+	 *
+	 * @constructor
+	 * @private
+	 * @alias sap.m.upload.UploaderTableItem
+	 */
+	var Uploader = Element.extend("sap.m.upload.UploaderTableItem", {
+		metadata: {
+			library: "sap.m",
+			publicMethods: [
+				"uploadItem",
+				"downloadItem"
+			],
+			properties: {
+				/**
+				 * URL where the next file is going to be uploaded to.
+				 */
+				uploadUrl: {type: "string", defaultValue: null},
+				/**
+				 * URL where the next file is going to be download from.
+				 */
+				downloadUrl: {type: "string", defaultValue: null},
+				/**
+				 * HTTP request method chosen for file upload.
+				 * @since 1.90
+				 */
+				httpRequestMethod: {type: "sap.m.upload.UploaderHttpRequestMethod", defaultValue: UploaderHttpRequestMethod.Post},
+				/**
+				* This property decides the type of request. If set to "true", the request gets sent as a multipart/form-data request instead of file only request.
+				* @since 1.92
+				*/
+				useMultipart: { type: "boolean", defaultValue: false }
+            },
+			events: {
+				/**
+				 * The event is fired just after the POST request was sent.
+				 */
+				uploadStarted: {
+					parameters: {
+						/**
+						 * The item that is going to be uploaded.
+						 */
+						item: {type: "sap.m.upload.UploadSetTableItem"}
+					}
+				},
+				/**
+				 * The event is fired every time an XHR request reports progress in uploading.
+				 */
+				uploadProgressed: {
+					parameters: {
+						/**
+						 * The item that is being uploaded.
+						 */
+						item: {type: "sap.m.upload.UploadSetTableItem"},
+						/**
+						 * The number of bytes transferred since the beginning of the operation.
+						 * This doesn't include headers and other overhead, but only the content itself
+						 */
+						loaded: {type: "int"},
+						/**
+						 * The total number of bytes of content that will be transferred during the operation.
+						 * If the total size is unknown, this value is zero.
+						 */
+						total: {type: "int"}
+					}
+				},
+				/**
+				 * The event is fired when an XHR request reports successful completion of upload process.
+				 */
+				uploadCompleted: {
+					parameters: {
+						/**
+						 * The item that was uploaded.
+						 */
+						item: {type: "sap.m.upload.UploadSetTableItem"},
+						/**
+						 * A JSON object containing the additional response parameters like response, responseXML, readyState, status and headers.
+						 * <i>Sample response object:</i>
+						 * <pre><code>
+						 * {
+						 *    response: "<!DOCTYPE html>\n<html>...</html>\n",
+						 *    responseXML: null,
+						 *    readyState: 2,
+						 *    status: 404,
+						 *    headers: "allow: GET, HEAD"
+						 * }
+						 * </code></pre>
+						 */
+						responseXHR: {type: "object"}
+					}
+				}
+			}
+		}
+	});
+
+	Uploader.prototype.init = function () {
+		this._mRequestHandlers = {};
+	};
+
+	/**
+	 * Starts function for uploading one file object to given url. Returns promise that resolves when the upload is finished or rejects when the upload fails.
+	 *
+	 * @param {File|Blob} oFile File or Blob object to be uploaded.
+	 * @param {string} sUrl Upload Url.
+	 * @param {sap.ui.core.Item[]} [aHeaderFields] Collection of request header fields to be send along.
+	 * @returns {Promise} Promise that resolves when the upload is finished or rejects when the upload fails.
+	 * @public
+	 */
+	Uploader.uploadFile = function (oFile, sUrl, aHeaderFields) {
+		var oXhr = new window.XMLHttpRequest();
+		var sHttpRequestMethod = this.getHttpRequestMethod();
+
+		return new Promise(function(resolve, reject) {
+			oXhr.open(sHttpRequestMethod, sUrl, true);
+
+			if ((Device.browser.edge || Device.browser.internet_explorer) && oFile.type && oXhr.readyState === 1) {
+				oXhr.setRequestHeader("Content-Type", oFile.type);
+			}
+
+			if (aHeaderFields) {
+				aHeaderFields.forEach(function (oHeader) {
+					oXhr.setRequestHeader(oHeader.getKey(), oHeader.getText());
+				});
+			}
+
+			oXhr.onreadystatechange = function () {
+				if (this.readyState === window.XMLHttpRequest.DONE) {
+					if (this.status === 200) {
+						resolve(this);
+					} else {
+						reject(this);
+					}
+				}
+			};
+
+			oXhr.send(oFile);
+		});
+	};
+
+	/**
+	 * Starts the process of uploading the specified file.
+	 *
+	 * @param {sap.m.upload.UploadSetTableItem} oItem Item representing the file to be uploaded.
+	 * @param {sap.ui.core.Item[]} [aHeaderFields] Collection of request header fields to be send along.
+	 * @public
+	 */
+	Uploader.prototype.uploadItem = function (oItem, aHeaderFields) {
+		var oXhr = new window.XMLHttpRequest(),
+			oFile = oItem.getFileObject(),
+			that = this,
+			oRequestHandler = {
+				xhr: oXhr,
+				item: oItem
+			},
+			sHttpRequestMethod = this.getHttpRequestMethod(),
+			sUploadUrl = oItem.getUploadUrl() || this.getUploadUrl();
+
+		oXhr.open(sHttpRequestMethod, sUploadUrl, true);
+
+		if ((Device.browser.edge || Device.browser.internet_explorer) && oFile.type && oXhr.readyState === 1) {
+			oXhr.setRequestHeader("Content-Type", oFile.type);
+		}
+
+		if (aHeaderFields) {
+			aHeaderFields.forEach(function (oHeader) {
+				oXhr.setRequestHeader(oHeader.getKey(), oHeader.getText());
+			});
+		}
+
+		oXhr.onreadystatechange = function () {
+			var oHandler = that._mRequestHandlers[oItem.getId()],
+				oResponseXHRParams = {};
+			if (this.readyState === window.XMLHttpRequest.DONE && !oHandler.aborted) {
+				oResponseXHRParams = {
+					"response": this.response,
+					"responseXML": this.responseXML,
+					"responseText": this.responseText,
+					"readyState": this.readyState,
+					"status": this.status,
+					"headers": this.getAllResponseHeaders()
+				};
+				that.fireUploadCompleted({item: oItem, responseXHR: oResponseXHRParams});
+			}
+		};
+
+		if (this.getUseMultipart()) {
+			var oFormData = new window.FormData();
+			var name = oFile ? oFile.name : null;
+			if (oFile instanceof window.Blob && name) {
+				oFormData.append(name, oFile, oFile.name);
+			} else {
+				oFormData.append(name, oFile);
+			}
+			oFormData.append("_charset_", "UTF-8");
+			oFile = oFormData;
+
+			this._mRequestHandlers[oItem.getId()] = oRequestHandler;
+			oXhr.send(oFile);
+			this.fireUploadStarted({item: oItem});
+		} else {
+			this._mRequestHandlers[oItem.getId()] = oRequestHandler;
+			oXhr.send(oFile);
+			this.fireUploadStarted({item: oItem});
+		}
+
+	};
+
+	/**
+	 * Starts the process of downloading a file.
+	 *
+	 * @param {sap.m.upload.UploadSetTableItem} oItem Item representing the file to be downloaded.
+	 * @param {sap.ui.core.Item[]} aHeaderFields List of header fields to be added to the GET request.
+	 * @param {boolean} bAskForLocation True if the location to where download the file should be first queried by a browser dialog.
+	 * @return {boolean} True if the download process successfully
+	 * @public
+	 */
+	Uploader.prototype.download = function (oItem, aHeaderFields, bAskForLocation) {
+		var sUrl = this.getDownloadUrl() || oItem.getUrl();
+
+		// File.save doesn't work in Safari but URLHelper.redirect does work.
+		// So, this overwrites the value of bAskForLocation in order to make it work.
+		if (Device.browser.name === "sf") {
+			bAskForLocation = false;
+		}
+		if (!oItem.getUrl()) {
+			Log.warning("Items to download do not have a URL.");
+			return false;
+		} else if (bAskForLocation) {
+			var oBlob = null,
+				oXhr = new window.XMLHttpRequest();
+			oXhr.open("GET", sUrl);
+
+			aHeaderFields.forEach(function (oHeader) {
+				oXhr.setRequestHeader(oHeader.getKey(), oHeader.getText());
+			});
+
+			oXhr.responseType = "blob"; // force the HTTP response, response-type header to be blob
+			oXhr.onload = function () {
+				var sFileName = oItem.getFileName(),
+					oSplit = UploadSetItem._splitFileName(sFileName, false);
+				oBlob = oXhr.response;
+				FileUtil.save(oBlob, oSplit.name, oSplit.extension, oItem.getMediaType(), "utf-8");
+			};
+			oXhr.send();
+			return true;
+		} else {
+			MobileLibrary.URLHelper.redirect(sUrl, true);
+			return true;
+		}
+	};
+
+	return Uploader;
+});