useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
*
* @returns {Promise} Promise that is resolved when the delete finishes.
*/
destroy() {
let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
if (!this._name) {
throw new _ParseError.default(_ParseError.default.FILE_DELETE_UNNAMED_ERROR, 'Cannot delete an unnamed file.');
}
const destroyOptions = {
useMasterKey: true
};
if (options.hasOwnProperty('useMasterKey')) {
destroyOptions.useMasterKey = !!options.useMasterKey;
}
const controller = _CoreManager.default.getFileController();
return controller.deleteFile(this._name, destroyOptions).then(() => {
this._data = undefined;
this._requestTask = null;
return this;
});
}
toJSON() {
return {
__type: 'File',
name: this._name,
url: this._url
};
}
equals(other) {
if (this === other) {
return true;
}
// Unsaved Files are never equal, since they will be saved to different URLs
return other instanceof ParseFile && this.name() === other.name() && this.url() === other.url() && typeof this.url() !== 'undefined';
}
/**
* Sets metadata to be saved with file object. Overwrites existing metadata
*
* @param {object} metadata Key value pairs to be stored with file object
*/
setMetadata(metadata) {
if (metadata && typeof metadata === 'object') {
var _context4;
(0, _forEach.default)(_context4 = (0, _keys.default)(metadata)).call(_context4, key => {
this.addMetadata(key, metadata[key]);
});
}
}
/**
* Sets metadata to be saved with file object. Adds to existing metadata.
*
* @param {string} key key to store the metadata
* @param {*} value metadata
*/
addMetadata(key, value) {
if (typeof key === 'string') {
this._metadata[key] = value;
}
}
/**
* Sets tags to be saved with file object. Overwrites existing tags
*
* @param {object} tags Key value pairs to be stored with file object
*/
setTags(tags) {
if (tags && typeof tags === 'object') {
var _context5;
(0, _forEach.default)(_context5 = (0, _keys.default)(tags)).call(_context5, key => {
this.addTag(key, tags[key]);
});
}
}
/**
* Sets tags to be saved with file object. Adds to existing tags.
*
* @param {string} key key to store tags
* @param {*} value tag
*/
addTag(key, value) {
if (typeof key === 'string') {
this._tags[key] = value;
}
}
static fromJSON(obj) {
if (obj.__type !== 'File') {
throw new TypeError('JSON object does not represent a ParseFile');
}
const file = new ParseFile(obj.name);
file._url = obj.url;
return file;
}
static encodeBase64(bytes) {
const chunks = [];
chunks.length = Math.ceil(bytes.length / 3);
for (let i = 0; i < chunks.length; i++) {
const b1 = bytes[i * 3];
const b2 = bytes[i * 3 + 1] || 0;
const b3 = bytes[i * 3 + 2] || 0;
const has2 = i * 3 + 1 < bytes.length;
const has3 = i * 3 + 2 < bytes.length;
chunks[i] = [b64Digit(b1 >> 2 & 0x3f), b64Digit(b1 << 4 & 0x30 | b2 >> 4 & 0x0f), has2 ? b64Digit(b2 << 2 & 0x3c | b3 >> 6 & 0x03) : '=', has3 ? b64Digit(b3 & 0x3f) : '='].join('');
}
return chunks.join('');
}
}
const DefaultController = {
saveFile: async function (name, source, options) {
if (source.format !== 'file') {
throw new Error('saveFile can only be used with File-type sources.');
}
const base64Data = await new _promise.default((res, rej) => {
// eslint-disable-next-line no-undef
const reader = new FileReader();
reader.onload = () => res(reader.result);
reader.onerror = error => rej(error);
reader.readAsDataURL(source.file);
});
// we only want the data after the comma
// For example: "data:application/pdf;base64,JVBERi0xLjQKJ..." we would only want "JVBERi0xLjQKJ..."
const [first, second] = base64Data.split(',');
// in the event there is no 'data:application/pdf;base64,' at the beginning of the base64 string
// use the entire string instead
const data = second ? second : first;
const newSource = {
format: 'base64',
base64: data,
type: source.type || (source.file ? source.file.type : undefined)
};
return await DefaultController.saveBase64(name, newSource, options);
},
saveBase64: function (name, source) {
let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
if (source.format !== 'base64') {
throw new Error('saveBase64 can only be used with Base64-type sources.');
}
const data = {
base64: source.base64,
fileData: {
metadata: {
...options.metadata
},
tags: {
...options.tags
}
}
};
delete options.metadata;
delete options.tags;
if (source.type) {
data._ContentType = source.type;
}
return _CoreManager.default.getRESTController().request('POST', 'files/' + name, data, options);
},
download: function (uri, options) {
if (XHR) {
return this.downloadAjax(uri, options);
} else {
return _promise.default.reject('Cannot make a request: No definition of XMLHttpRequest was found.');
}
},
downloadAjax: function (uri, options) {
return new _promise.default((resolve, reject) => {
const xhr = new XHR();
xhr.open('GET', uri, true);
xhr.responseType = 'arraybuffer';
xhr.onerror = function (e) {
reject(e);
};
xhr.onreadystatechange = function () {
if (xhr.readyState !== xhr.DONE) {
return;
}
if (!this.response) {
return resolve({});
}
const bytes = new Uint8Array(this.response);
resolve({
base64: ParseFile.encodeBase64(bytes),
contentType: xhr.getResponseHeader('content-type')
});
};
options.requestTask(xhr);
xhr.send();
});
},
deleteFile: function (name, options) {
const headers = {
'X-Parse-Application-ID': _CoreManager.default.get('APPLICATION_ID')
};
if (options.useMasterKey) {
headers['X-Parse-Master-Key'] = _CoreManager.default.get('MASTER_KEY');
}
let url = _CoreManager.default.get('SERVER_URL');
if (url[url.length - 1] !== '/') {
url += '/';
}
url += 'files/' + name;
return _CoreManager.default.getRESTController().ajax('DELETE', url, '', headers).catch(response => {
// TODO: return JSON object in server
if (!response || response === 'SyntaxError: Unexpected end of JSON input') {
return _promise.default.resolve();
} else {
return _CoreManager.default.getRESTController().handleError(response);
}
});
},
_setXHR(xhr) {
XHR = xhr;
},
_getXHR() {
return XHR;
}
};
_CoreManager.default.setFileController(DefaultController);
var _default = exports.default = ParseFile;
exports.b64Digit = b64Digit;