1168 lines
40 KiB
TypeScript
1168 lines
40 KiB
TypeScript
// (C) Copyright 2015 Moodle Pty Ltd.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
import { Injectable } from '@angular/core';
|
|
import { HttpClient, HttpResponse } from '@angular/common/http';
|
|
import { TranslateService } from '@ngx-translate/core';
|
|
import { FileTransfer, FileUploadOptions } from '@ionic-native/file-transfer';
|
|
import { CoreAppProvider } from './app';
|
|
import { CoreFileProvider } from './file';
|
|
import { CoreLoggerProvider } from './logger';
|
|
import { CoreMimetypeUtilsProvider } from './utils/mimetype';
|
|
import { CoreTextUtilsProvider } from './utils/text';
|
|
import { CoreConstants } from '@core/constants';
|
|
import { Md5 } from 'ts-md5/dist/md5';
|
|
import { CoreInterceptor } from '@classes/interceptor';
|
|
import { makeSingleton } from '@singletons/core.singletons';
|
|
import { Observable } from 'rxjs/Observable';
|
|
import { CoreNativeToAngularHttpResponse } from '@classes/native-to-angular-http';
|
|
|
|
/**
|
|
* PreSets accepted by the WS call.
|
|
*/
|
|
export interface CoreWSPreSets {
|
|
/**
|
|
* The site URL.
|
|
*/
|
|
siteUrl: string;
|
|
|
|
/**
|
|
* The Webservice token.
|
|
*/
|
|
wsToken: string;
|
|
|
|
/**
|
|
* Defaults to true. Set to false when the expected response is null.
|
|
*/
|
|
responseExpected?: boolean;
|
|
|
|
/**
|
|
* Defaults to 'object'. Use it when you expect a type that's not an object|array.
|
|
*/
|
|
typeExpected?: string;
|
|
|
|
/**
|
|
* Defaults to false. Clean multibyte Unicode chars from data.
|
|
*/
|
|
cleanUnicode?: boolean;
|
|
}
|
|
|
|
/**
|
|
* PreSets accepted by AJAX WS calls.
|
|
*/
|
|
export interface CoreWSAjaxPreSets {
|
|
/**
|
|
* The site URL.
|
|
*/
|
|
siteUrl: string;
|
|
|
|
/**
|
|
* Defaults to true. Set to false when the expected response is null.
|
|
*/
|
|
responseExpected?: boolean;
|
|
|
|
/**
|
|
* Whether to use the no-login endpoint instead of the normal one. Use it for requests that don't require authentication.
|
|
*/
|
|
noLogin?: boolean;
|
|
|
|
/**
|
|
* Whether to send the parameters via GET. Only if noLogin is true.
|
|
*/
|
|
useGet?: boolean;
|
|
}
|
|
|
|
/**
|
|
* Options for HTTP requests.
|
|
*/
|
|
export type HttpRequestOptions = {
|
|
/**
|
|
* The HTTP method.
|
|
*/
|
|
method: string;
|
|
|
|
/**
|
|
* Payload to send to the server. Only applicable on post, put or patch methods.
|
|
*/
|
|
data?: any;
|
|
|
|
/**
|
|
* Query params to be appended to the URL (only applicable on get, head, delete, upload or download methods).
|
|
*/
|
|
params?: any;
|
|
|
|
/**
|
|
* Response type. Defaults to json.
|
|
*/
|
|
responseType?: 'json' | 'text' | 'arraybuffer' | 'blob';
|
|
|
|
/**
|
|
* Timeout for the request in seconds. If undefined, the default value will be used. If null, no timeout.
|
|
*/
|
|
timeout?: number | null;
|
|
|
|
/**
|
|
* Serializer to use. Defaults to 'urlencoded'. Only for mobile environments.
|
|
*/
|
|
serializer?: string;
|
|
|
|
/**
|
|
* Whether to follow redirects. Defaults to true. Only for mobile environments.
|
|
*/
|
|
followRedirect?: boolean;
|
|
|
|
/**
|
|
* Headers. Only for mobile environments.
|
|
*/
|
|
headers?: {[name: string]: string};
|
|
|
|
/**
|
|
* File paths to use for upload or download. Only for mobile environments.
|
|
*/
|
|
filePath?: string;
|
|
|
|
/**
|
|
* Name to use during upload. Only for mobile environments.
|
|
*/
|
|
name?: string;
|
|
};
|
|
|
|
/**
|
|
* This service allows performing WS calls and download/upload files.
|
|
*/
|
|
@Injectable()
|
|
export class CoreWSProvider {
|
|
protected logger;
|
|
protected mimeTypeCache = {}; // A "cache" to store file mimetypes to prevent performing too many HEAD requests.
|
|
protected ongoingCalls = {};
|
|
protected retryCalls = [];
|
|
protected retryTimeout = 0;
|
|
|
|
constructor(protected http: HttpClient,
|
|
protected translate: TranslateService,
|
|
protected appProvider: CoreAppProvider,
|
|
protected textUtils: CoreTextUtilsProvider,
|
|
protected fileProvider: CoreFileProvider,
|
|
protected fileTransfer: FileTransfer,
|
|
protected mimeUtils: CoreMimetypeUtilsProvider,
|
|
logger: CoreLoggerProvider) {
|
|
this.logger = logger.getInstance('CoreWSProvider');
|
|
}
|
|
|
|
/**
|
|
* Adds the call data to an special queue to be processed when retrying.
|
|
*
|
|
* @param method The WebService method to be called.
|
|
* @param siteUrl Complete site url to perform the call.
|
|
* @param ajaxData Arguments to pass to the method.
|
|
* @param preSets Extra settings and information.
|
|
* @return Deferred promise resolved with the response data in success and rejected with the error message
|
|
* if it fails.
|
|
*/
|
|
protected addToRetryQueue(method: string, siteUrl: string, ajaxData: any, preSets: CoreWSPreSets): Promise<any> {
|
|
const call: any = {
|
|
method: method,
|
|
siteUrl: siteUrl,
|
|
ajaxData: ajaxData,
|
|
preSets: preSets,
|
|
deferred: {}
|
|
};
|
|
|
|
call.deferred.promise = new Promise((resolve, reject): void => {
|
|
call.deferred.resolve = resolve;
|
|
call.deferred.reject = reject;
|
|
});
|
|
|
|
this.retryCalls.push(call);
|
|
|
|
return call.deferred.promise;
|
|
}
|
|
|
|
/**
|
|
* A wrapper function for a moodle WebService call.
|
|
*
|
|
* @param method The WebService method to be called.
|
|
* @param data Arguments to pass to the method. It's recommended to call convertValuesToString before passing the data.
|
|
* @param preSets Extra settings and information.
|
|
* @return Promise resolved with the response data in success and rejected if it fails.
|
|
*/
|
|
call(method: string, data: any, preSets: CoreWSPreSets): Promise<any> {
|
|
|
|
let siteUrl;
|
|
|
|
if (!preSets) {
|
|
return Promise.reject(this.createFakeWSError('core.unexpectederror', true));
|
|
} else if (!this.appProvider.isOnline()) {
|
|
return Promise.reject(this.createFakeWSError('core.networkerrormsg', true));
|
|
}
|
|
|
|
preSets.typeExpected = preSets.typeExpected || 'object';
|
|
if (typeof preSets.responseExpected == 'undefined') {
|
|
preSets.responseExpected = true;
|
|
}
|
|
|
|
data = Object.assign({}, data); // Create a new object so the changes don't affect the original data.
|
|
data.wsfunction = method;
|
|
data.wstoken = preSets.wsToken;
|
|
siteUrl = preSets.siteUrl + '/webservice/rest/server.php?moodlewsrestformat=json';
|
|
|
|
// There are some ongoing retry calls, wait for timeout.
|
|
if (this.retryCalls.length > 0) {
|
|
this.logger.warn('Calls locked, trying later...');
|
|
|
|
return this.addToRetryQueue(method, siteUrl, data, preSets);
|
|
} else {
|
|
return this.performPost(method, siteUrl, data, preSets);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call a Moodle WS using the AJAX API. Please use it if the WS layer is not an option.
|
|
* It uses a cache to prevent duplicate requests.
|
|
*
|
|
* @param method The WebService method to be called.
|
|
* @param data Arguments to pass to the method.
|
|
* @param preSets Extra settings and information. Only some
|
|
* @return Promise resolved with the response data in success and rejected with an object containing:
|
|
* - error: Error message.
|
|
* - errorcode: Error code returned by the site (if any).
|
|
* - available: 0 if unknown, 1 if available, -1 if not available.
|
|
*/
|
|
callAjax(method: string, data: any, preSets: CoreWSAjaxPreSets): Promise<any> {
|
|
const cacheParams = {
|
|
methodname: method,
|
|
args: data,
|
|
};
|
|
|
|
let promise = this.getPromiseHttp('ajax', preSets.siteUrl, cacheParams);
|
|
|
|
if (!promise) {
|
|
promise = this.performAjax(method, data, preSets);
|
|
promise = this.setPromiseHttp(promise, 'ajax', preSets.siteUrl, cacheParams);
|
|
}
|
|
|
|
return promise;
|
|
}
|
|
|
|
/**
|
|
* Converts an objects values to strings where appropriate.
|
|
* Arrays (associative or otherwise) will be maintained, null values will be removed.
|
|
*
|
|
* @param data The data that needs all the non-object values set to strings.
|
|
* @param stripUnicode If Unicode long chars need to be stripped.
|
|
* @return The cleaned object or null if some strings becomes empty after stripping Unicode.
|
|
*/
|
|
convertValuesToString(data: any, stripUnicode?: boolean): any {
|
|
const result: any = Array.isArray(data) ? [] : {};
|
|
|
|
for (const key in data) {
|
|
let value = data[key];
|
|
|
|
if (value == null) {
|
|
// Skip null or undefined value.
|
|
continue;
|
|
} else if (typeof value == 'object') {
|
|
// Object or array.
|
|
value = this.convertValuesToString(value, stripUnicode);
|
|
if (value == null) {
|
|
return null;
|
|
}
|
|
} else if (typeof value == 'string') {
|
|
if (stripUnicode) {
|
|
const stripped = this.textUtils.stripUnicode(value);
|
|
if (stripped != value && stripped.trim().length == 0) {
|
|
return null;
|
|
}
|
|
value = stripped;
|
|
}
|
|
} else if (typeof value == 'boolean') {
|
|
/* Moodle does not allow "true" or "false" in WS parameters, only in POST parameters.
|
|
We've been using "true" and "false" for WS settings "filter" and "fileurl",
|
|
we keep it this way to avoid changing cache keys. */
|
|
if (key == 'moodlewssettingfilter' || key == 'moodlewssettingfileurl') {
|
|
value = value ? 'true' : 'false';
|
|
} else {
|
|
value = value ? '1' : '0';
|
|
}
|
|
} else if (typeof value == 'number') {
|
|
value = String(value);
|
|
} else {
|
|
// Unknown type.
|
|
continue;
|
|
}
|
|
|
|
if (Array.isArray(result)) {
|
|
result.push(value);
|
|
} else {
|
|
result[key] = value;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Create a "fake" WS error for local errors.
|
|
*
|
|
* @param message The message to include in the error.
|
|
* @param needsTranslate If the message needs to be translated.
|
|
* @param translateParams Translation params, if needed.
|
|
* @return Fake WS error.
|
|
*/
|
|
createFakeWSError(message: string, needsTranslate?: boolean, translateParams?: {}): CoreWSError {
|
|
if (needsTranslate) {
|
|
message = this.translate.instant(message, translateParams);
|
|
}
|
|
|
|
return {
|
|
message: message
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Downloads a file from Moodle using Cordova File API.
|
|
*
|
|
* @param url Download url.
|
|
* @param path Local path to store the file.
|
|
* @param addExtension True if extension need to be added to the final path.
|
|
* @param onProgress Function to call on progress.
|
|
* @return Promise resolved with the downloaded file.
|
|
*/
|
|
downloadFile(url: string, path: string, addExtension?: boolean, onProgress?: (event: ProgressEvent) => any): Promise<any> {
|
|
this.logger.debug('Downloading file', url, path, addExtension);
|
|
|
|
if (!this.appProvider.isOnline()) {
|
|
return Promise.reject(this.translate.instant('core.networkerrormsg'));
|
|
}
|
|
|
|
// Use a tmp path to download the file and then move it to final location.
|
|
// This is because if the download fails, the local file is deleted.
|
|
const tmpPath = path + '.tmp';
|
|
|
|
// Create the tmp file as an empty file.
|
|
return this.fileProvider.createFile(tmpPath).then((fileEntry) => {
|
|
const transfer = this.fileTransfer.create();
|
|
transfer.onProgress(onProgress);
|
|
|
|
return transfer.download(url, fileEntry.toURL(), true).then(() => {
|
|
let promise;
|
|
|
|
if (addExtension) {
|
|
const ext = this.mimeUtils.getFileExtension(path);
|
|
|
|
// Google Drive extensions will be considered invalid since Moodle usually converts them.
|
|
if (!ext || ext == 'gdoc' || ext == 'gsheet' || ext == 'gslides' || ext == 'gdraw' || ext == 'php') {
|
|
// Not valid, get the file's mimetype.
|
|
promise = this.getRemoteFileMimeType(url).then((mime) => {
|
|
if (mime) {
|
|
const remoteExt = this.mimeUtils.getExtension(mime, url);
|
|
// If the file is from Google Drive, ignore mimetype application/json.
|
|
if (remoteExt && (!ext || mime != 'application/json')) {
|
|
if (ext) {
|
|
// Remove existing extension since we will use another one.
|
|
path = this.mimeUtils.removeExtension(path);
|
|
}
|
|
path += '.' + remoteExt;
|
|
|
|
return remoteExt;
|
|
}
|
|
}
|
|
|
|
return ext;
|
|
});
|
|
} else {
|
|
promise = Promise.resolve(ext);
|
|
}
|
|
} else {
|
|
promise = Promise.resolve('');
|
|
}
|
|
|
|
return promise.then((extension) => {
|
|
return this.fileProvider.moveFile(tmpPath, path).then((movedEntry) => {
|
|
// Save the extension.
|
|
movedEntry.extension = extension;
|
|
movedEntry.path = path;
|
|
this.logger.debug(`Success downloading file ${url} to ${path} with extension ${extension}`);
|
|
|
|
return movedEntry;
|
|
});
|
|
});
|
|
});
|
|
}).catch((err) => {
|
|
this.logger.error(`Error downloading ${url} to ${path}`, err);
|
|
|
|
return Promise.reject(err);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get a promise from the cache.
|
|
*
|
|
* @param method Method of the HTTP request.
|
|
* @param url Base URL of the HTTP request.
|
|
* @param params Params of the HTTP request.
|
|
*/
|
|
protected getPromiseHttp(method: string, url: string, params?: any): any {
|
|
const queueItemId = this.getQueueItemId(method, url, params);
|
|
if (typeof this.ongoingCalls[queueItemId] != 'undefined') {
|
|
return this.ongoingCalls[queueItemId];
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Perform a HEAD request to get the mimetype of a remote file.
|
|
*
|
|
* @param url File URL.
|
|
* @param ignoreCache True to ignore cache, false otherwise.
|
|
* @return Promise resolved with the mimetype or '' if failure.
|
|
*/
|
|
getRemoteFileMimeType(url: string, ignoreCache?: boolean): Promise<string> {
|
|
if (this.mimeTypeCache[url] && !ignoreCache) {
|
|
return Promise.resolve(this.mimeTypeCache[url]);
|
|
}
|
|
|
|
return this.performHead(url).then((response) => {
|
|
let mimeType = response.headers.get('Content-Type');
|
|
if (mimeType) {
|
|
// Remove "parameters" like charset.
|
|
mimeType = mimeType.split(';')[0];
|
|
}
|
|
this.mimeTypeCache[url] = mimeType;
|
|
|
|
return mimeType || '';
|
|
}).catch(() => {
|
|
// Error, resolve with empty mimetype.
|
|
return '';
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Perform a HEAD request to get the size of a remote file.
|
|
*
|
|
* @param url File URL.
|
|
* @return Promise resolved with the size or -1 if failure.
|
|
*/
|
|
getRemoteFileSize(url: string): Promise<number> {
|
|
return this.performHead(url).then((response) => {
|
|
const size = parseInt(response.headers.get('Content-Length'), 10);
|
|
|
|
if (size) {
|
|
return size;
|
|
}
|
|
|
|
return -1;
|
|
}).catch(() => {
|
|
// Error, return -1.
|
|
return -1;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get a request timeout based on the network connection.
|
|
*
|
|
* @return Timeout in ms.
|
|
*/
|
|
getRequestTimeout(): number {
|
|
return this.appProvider.isNetworkAccessLimited() ? CoreConstants.WS_TIMEOUT : CoreConstants.WS_TIMEOUT_WIFI;
|
|
}
|
|
|
|
/**
|
|
* Get the unique queue item id of the cache for a HTTP request.
|
|
*
|
|
* @param method Method of the HTTP request.
|
|
* @param url Base URL of the HTTP request.
|
|
* @param params Params of the HTTP request.
|
|
* @return Queue item ID.
|
|
*/
|
|
protected getQueueItemId(method: string, url: string, params?: any): string {
|
|
if (params) {
|
|
url += '###' + CoreInterceptor.serialize(params);
|
|
}
|
|
|
|
return method + '#' + Md5.hashAsciiStr(url);
|
|
}
|
|
|
|
/**
|
|
* Call a Moodle WS using the AJAX API.
|
|
*
|
|
* @param method The WebService method to be called.
|
|
* @param data Arguments to pass to the method.
|
|
* @param preSets Extra settings and information. Only some
|
|
* @return Promise resolved with the response data in success and rejected with an object containing:
|
|
* - error: Error message.
|
|
* - errorcode: Error code returned by the site (if any).
|
|
* - available: 0 if unknown, 1 if available, -1 if not available.
|
|
*/
|
|
protected performAjax(method: string, data: any, preSets: CoreWSAjaxPreSets): Promise<any> {
|
|
|
|
let promise;
|
|
|
|
if (typeof preSets.siteUrl == 'undefined') {
|
|
return rejectWithError(this.createFakeWSError('core.unexpectederror', true));
|
|
} else if (!this.appProvider.isOnline()) {
|
|
return rejectWithError(this.createFakeWSError('core.networkerrormsg', true));
|
|
}
|
|
|
|
if (typeof preSets.responseExpected == 'undefined') {
|
|
preSets.responseExpected = true;
|
|
}
|
|
|
|
const script = preSets.noLogin ? 'service-nologin.php' : 'service.php';
|
|
const ajaxData = [{
|
|
index: 0,
|
|
methodname: method,
|
|
args: this.convertValuesToString(data)
|
|
}];
|
|
|
|
// The info= parameter has no function. It is just to help with debugging.
|
|
// We call it info to match the parameter name use by Moodle's AMD ajax module.
|
|
let siteUrl = preSets.siteUrl + '/lib/ajax/' + script + '?info=' + method;
|
|
|
|
if (preSets.noLogin && preSets.useGet) {
|
|
// Send params using GET.
|
|
siteUrl += '&args=' + encodeURIComponent(JSON.stringify(ajaxData));
|
|
|
|
promise = this.sendHTTPRequest(siteUrl, {
|
|
method: 'get',
|
|
});
|
|
} else {
|
|
promise = this.sendHTTPRequest(siteUrl, {
|
|
method: 'post',
|
|
data: ajaxData,
|
|
serializer: 'json',
|
|
});
|
|
}
|
|
|
|
return promise.then((response: HttpResponse<any>) => {
|
|
let data = response.body;
|
|
|
|
// Some moodle web services return null.
|
|
// If the responseExpected value is set then so long as no data is returned, we create a blank object.
|
|
if (!data && !preSets.responseExpected) {
|
|
data = [{}];
|
|
}
|
|
|
|
// Check if error. Ajax layer should always return an object (if error) or an array (if success).
|
|
if (!data || typeof data != 'object') {
|
|
return rejectWithError(this.createFakeWSError('core.serverconnection', true));
|
|
} else if (data.error) {
|
|
return rejectWithError(data);
|
|
}
|
|
|
|
// Get the first response since only one request was done.
|
|
data = data[0];
|
|
|
|
if (data.error) {
|
|
return rejectWithError(data.exception);
|
|
}
|
|
|
|
return data.data;
|
|
}, (data) => {
|
|
const available = data.status == 404 ? -1 : 0;
|
|
|
|
return rejectWithError(this.createFakeWSError('core.serverconnection', true), available);
|
|
});
|
|
|
|
// Convenience function to return an error.
|
|
function rejectWithError(exception: any, available?: number): Promise<never> {
|
|
if (typeof available == 'undefined') {
|
|
if (exception.errorcode) {
|
|
available = exception.errorcode == 'invalidrecord' ? -1 : 1;
|
|
} else {
|
|
available = 0;
|
|
}
|
|
}
|
|
|
|
exception.available = available;
|
|
|
|
return Promise.reject(exception);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Perform a HEAD request and save the promise while waiting to be resolved.
|
|
*
|
|
* @param url URL to perform the request.
|
|
* @return Promise resolved with the response.
|
|
*/
|
|
performHead(url: string): Promise<HttpResponse<any>> {
|
|
let promise = this.getPromiseHttp('head', url);
|
|
|
|
if (!promise) {
|
|
promise = this.sendHTTPRequest(url, {
|
|
method: 'head',
|
|
responseType: 'text',
|
|
});
|
|
|
|
promise = this.setPromiseHttp(promise, 'head', url);
|
|
}
|
|
|
|
return promise;
|
|
}
|
|
|
|
/**
|
|
* Perform the post call and save the promise while waiting to be resolved.
|
|
*
|
|
* @param method The WebService method to be called.
|
|
* @param siteUrl Complete site url to perform the call.
|
|
* @param ajaxData Arguments to pass to the method.
|
|
* @param preSets Extra settings and information.
|
|
* @return Promise resolved with the response data in success and rejected with CoreWSError if it fails.
|
|
*/
|
|
performPost(method: string, siteUrl: string, ajaxData: any, preSets: CoreWSPreSets): Promise<any> {
|
|
const options = {};
|
|
|
|
// This is done because some returned values like 0 are treated as null if responseType is json.
|
|
if (preSets.typeExpected == 'number' || preSets.typeExpected == 'boolean' || preSets.typeExpected == 'string') {
|
|
// Avalaible values are: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType
|
|
options['responseType'] = 'text';
|
|
}
|
|
|
|
// We add the method name to the URL purely to help with debugging.
|
|
// This duplicates what is in the ajaxData, but that does no harm.
|
|
// POST variables take precedence over GET.
|
|
const requestUrl = siteUrl + '&wsfunction=' + method;
|
|
|
|
// Perform the post request.
|
|
const promise = this.http.post(requestUrl, ajaxData, options).timeout(this.getRequestTimeout()).toPromise();
|
|
|
|
return promise.then((data: any) => {
|
|
|
|
// Some moodle web services return null.
|
|
// If the responseExpected value is set to false, we create a blank object if the response is null.
|
|
if (!data && !preSets.responseExpected) {
|
|
data = {};
|
|
}
|
|
|
|
if (!data) {
|
|
return Promise.reject(this.createFakeWSError('core.serverconnection', true));
|
|
} else if (typeof data != preSets.typeExpected) {
|
|
// If responseType is text an string will be returned, parse before returning.
|
|
if (typeof data == 'string') {
|
|
if (preSets.typeExpected == 'number') {
|
|
data = Number(data);
|
|
if (isNaN(data)) {
|
|
this.logger.warn(`Response expected type "${preSets.typeExpected}" cannot be parsed to number`);
|
|
|
|
return Promise.reject(this.createFakeWSError('core.errorinvalidresponse', true));
|
|
}
|
|
} else if (preSets.typeExpected == 'boolean') {
|
|
if (data === 'true') {
|
|
data = true;
|
|
} else if (data === 'false') {
|
|
data = false;
|
|
} else {
|
|
this.logger.warn(`Response expected type "${preSets.typeExpected}" is not true or false`);
|
|
|
|
return Promise.reject(this.createFakeWSError('core.errorinvalidresponse', true));
|
|
}
|
|
} else {
|
|
this.logger.warn('Response of type "' + typeof data + `" received, expecting "${preSets.typeExpected}"`);
|
|
|
|
return Promise.reject(this.createFakeWSError('core.errorinvalidresponse', true));
|
|
}
|
|
} else {
|
|
this.logger.warn('Response of type "' + typeof data + `" received, expecting "${preSets.typeExpected}"`);
|
|
|
|
return Promise.reject(this.createFakeWSError('core.errorinvalidresponse', true));
|
|
}
|
|
}
|
|
|
|
if (typeof data.exception !== 'undefined') {
|
|
// Special debugging for site plugins, otherwise it's hard to debug errors if the data is cached.
|
|
if (method == 'tool_mobile_get_content') {
|
|
this.logger.error('Error calling WS', method, data);
|
|
}
|
|
|
|
return Promise.reject(data);
|
|
}
|
|
|
|
if (typeof data.debuginfo != 'undefined') {
|
|
return Promise.reject(this.createFakeWSError('Error. ' + data.message));
|
|
}
|
|
|
|
return data;
|
|
}, (error) => {
|
|
// If server has heavy load, retry after some seconds.
|
|
if (error.status == 429) {
|
|
const retryPromise = this.addToRetryQueue(method, siteUrl, ajaxData, preSets);
|
|
|
|
// Only process the queue one time.
|
|
if (this.retryTimeout == 0) {
|
|
this.retryTimeout = parseInt(error.headers.get('Retry-After'), 10) || 5;
|
|
this.logger.warn(`${error.statusText}. Retrying in ${this.retryTimeout} seconds. ` +
|
|
`${this.retryCalls.length} calls left.`);
|
|
|
|
setTimeout(() => {
|
|
this.logger.warn(`Retrying now with ${this.retryCalls.length} calls to process.`);
|
|
// Finish timeout.
|
|
this.retryTimeout = 0;
|
|
this.processRetryQueue();
|
|
}, this.retryTimeout * 1000);
|
|
} else {
|
|
this.logger.warn('Calls locked, trying later...');
|
|
}
|
|
|
|
return retryPromise;
|
|
}
|
|
|
|
return Promise.reject(this.createFakeWSError('core.serverconnection', true));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Retry all requests in the queue.
|
|
* This function uses recursion in order to add a delay between requests to reduce stress.
|
|
*/
|
|
protected processRetryQueue(): void {
|
|
if (this.retryCalls.length > 0 && this.retryTimeout == 0) {
|
|
const call = this.retryCalls.shift();
|
|
// Add a delay between calls.
|
|
setTimeout(() => {
|
|
call.deferred.resolve(this.performPost(call.method, call.siteUrl, call.ajaxData, call.preSets));
|
|
this.processRetryQueue();
|
|
}, 200);
|
|
} else {
|
|
this.logger.warn(`Retry queue has stopped with ${this.retryCalls.length} calls and ${this.retryTimeout} timeout secs.`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save promise on the cache.
|
|
*
|
|
* @param promise Promise to be saved.
|
|
* @param method Method of the HTTP request.
|
|
* @param url Base URL of the HTTP request.
|
|
* @param params Params of the HTTP request.
|
|
* @return The promise saved.
|
|
*/
|
|
protected setPromiseHttp(promise: Promise<any>, method: string, url: string, params?: any): Promise<any> {
|
|
const queueItemId = this.getQueueItemId(method, url, params);
|
|
let timeout;
|
|
|
|
this.ongoingCalls[queueItemId] = promise;
|
|
|
|
// HTTP not finished, but we should delete the promise after timeout.
|
|
timeout = setTimeout(() => {
|
|
delete this.ongoingCalls[queueItemId];
|
|
}, this.getRequestTimeout());
|
|
|
|
// HTTP finished, delete from ongoing.
|
|
return promise.finally(() => {
|
|
delete this.ongoingCalls[queueItemId];
|
|
|
|
clearTimeout(timeout);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* A wrapper function for a synchronous Moodle WebService call.
|
|
* Warning: This function should only be used if synchronous is a must. It's recommended to use call.
|
|
*
|
|
* @param method The WebService method to be called.
|
|
* @param data Arguments to pass to the method.
|
|
* @param preSets Extra settings and information.
|
|
* @return Promise resolved with the response data in success and rejected with the error message if it fails.
|
|
* @return Request response. If the request fails, returns an object with 'error'=true and 'message' properties.
|
|
*/
|
|
syncCall(method: string, data: any, preSets: CoreWSPreSets): any {
|
|
const errorResponse = {
|
|
error: true,
|
|
message: ''
|
|
};
|
|
let siteUrl,
|
|
xhr;
|
|
|
|
if (!preSets) {
|
|
errorResponse.message = this.translate.instant('core.unexpectederror');
|
|
|
|
return errorResponse;
|
|
} else if (!this.appProvider.isOnline()) {
|
|
errorResponse.message = this.translate.instant('core.networkerrormsg');
|
|
|
|
return errorResponse;
|
|
}
|
|
|
|
preSets.typeExpected = preSets.typeExpected || 'object';
|
|
if (typeof preSets.responseExpected == 'undefined') {
|
|
preSets.responseExpected = true;
|
|
}
|
|
|
|
data = this.convertValuesToString(data || {}, preSets.cleanUnicode);
|
|
if (data == null) {
|
|
// Empty cleaned text found.
|
|
errorResponse.message = this.translate.instant('core.unicodenotsupportedcleanerror');
|
|
|
|
return errorResponse;
|
|
}
|
|
|
|
data.wsfunction = method;
|
|
data.wstoken = preSets.wsToken;
|
|
siteUrl = preSets.siteUrl + '/webservice/rest/server.php?moodlewsrestformat=json';
|
|
|
|
// Serialize data.
|
|
data = CoreInterceptor.serialize(data);
|
|
|
|
// Perform sync request using XMLHttpRequest.
|
|
xhr = new (<any> window).XMLHttpRequest();
|
|
xhr.open('post', siteUrl, false);
|
|
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded;charset=utf-8');
|
|
|
|
xhr.send(data);
|
|
|
|
// Get response.
|
|
data = ('response' in xhr) ? xhr.response : xhr.responseText;
|
|
|
|
// Check status.
|
|
const status = Math.max(xhr.status === 1223 ? 204 : xhr.status, 0);
|
|
if (status < 200 || status >= 300) {
|
|
// Request failed.
|
|
errorResponse.message = data;
|
|
|
|
return errorResponse;
|
|
}
|
|
|
|
// Treat response.
|
|
data = this.textUtils.parseJSON(data);
|
|
|
|
// Some moodle web services return null.
|
|
// If the responseExpected value is set then so long as no data is returned, we create a blank object.
|
|
if ((!data || !data.data) && !preSets.responseExpected) {
|
|
data = {};
|
|
}
|
|
|
|
if (!data) {
|
|
errorResponse.message = this.translate.instant('core.serverconnection');
|
|
} else if (typeof data != preSets.typeExpected) {
|
|
this.logger.warn('Response of type "' + typeof data + '" received, expecting "' + preSets.typeExpected + '"');
|
|
errorResponse.message = this.translate.instant('core.errorinvalidresponse');
|
|
}
|
|
|
|
if (typeof data.exception != 'undefined' || typeof data.debuginfo != 'undefined') {
|
|
errorResponse.message = data.message;
|
|
}
|
|
|
|
if (errorResponse.message !== '') {
|
|
return errorResponse;
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
/*
|
|
* Uploads a file.
|
|
*
|
|
* @param filePath File path.
|
|
* @param options File upload options.
|
|
* @param preSets Must contain siteUrl and wsToken.
|
|
* @param onProgress Function to call on progress.
|
|
* @return Promise resolved when uploaded.
|
|
*/
|
|
uploadFile(filePath: string, options: CoreWSFileUploadOptions, preSets: CoreWSPreSets,
|
|
onProgress?: (event: ProgressEvent) => any): Promise<any> {
|
|
this.logger.debug(`Trying to upload file: ${filePath}`);
|
|
|
|
if (!filePath || !options || !preSets) {
|
|
return Promise.reject(null);
|
|
}
|
|
|
|
if (!this.appProvider.isOnline()) {
|
|
return Promise.reject(this.translate.instant('core.networkerrormsg'));
|
|
}
|
|
|
|
const uploadUrl = preSets.siteUrl + '/webservice/upload.php',
|
|
transfer = this.fileTransfer.create();
|
|
|
|
transfer.onProgress(onProgress);
|
|
|
|
options.httpMethod = 'POST';
|
|
options.params = {
|
|
token: preSets.wsToken,
|
|
filearea: options.fileArea || 'draft',
|
|
itemid: options.itemId || 0
|
|
};
|
|
options.chunkedMode = false;
|
|
options.headers = {
|
|
Connection: 'close'
|
|
};
|
|
|
|
return transfer.upload(filePath, uploadUrl, options, true).then((success) => {
|
|
const data = this.textUtils.parseJSON(success.response, null,
|
|
this.logger.error.bind(this.logger, 'Error parsing response from upload', success.response));
|
|
if (data === null) {
|
|
return Promise.reject(this.translate.instant('core.errorinvalidresponse'));
|
|
}
|
|
|
|
if (!data) {
|
|
return Promise.reject(this.translate.instant('core.serverconnection'));
|
|
} else if (typeof data != 'object') {
|
|
this.logger.warn('Upload file: Response of type "' + typeof data + '" received, expecting "object"');
|
|
|
|
return Promise.reject(this.translate.instant('core.errorinvalidresponse'));
|
|
}
|
|
|
|
if (typeof data.exception !== 'undefined') {
|
|
return Promise.reject(data.message);
|
|
} else if (data && typeof data.error !== 'undefined') {
|
|
return Promise.reject(data.error);
|
|
} else if (data[0] && typeof data[0].error !== 'undefined') {
|
|
return Promise.reject(data[0].error);
|
|
}
|
|
|
|
// We uploaded only 1 file, so we only return the first file returned.
|
|
this.logger.debug('Successfully uploaded file', filePath);
|
|
|
|
return data[0];
|
|
}).catch((error) => {
|
|
this.logger.error('Error while uploading file', filePath, error);
|
|
|
|
return Promise.reject(this.translate.instant('core.errorinvalidresponse'));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Perform an HTTP request requesting for a text response.
|
|
*
|
|
* @param url Url to get.
|
|
* @return Resolved with the text when done.
|
|
*/
|
|
async getText(url: string): Promise<string> {
|
|
// Fetch the URL content.
|
|
const options: HttpRequestOptions = {
|
|
method: 'get',
|
|
responseType: 'text',
|
|
};
|
|
|
|
const response = await this.sendHTTPRequest(url, options);
|
|
|
|
const content = response.body;
|
|
|
|
if (typeof content !== 'string') {
|
|
throw 'Error reading content';
|
|
}
|
|
|
|
return content;
|
|
}
|
|
|
|
/**
|
|
* Send an HTTP request. In mobile devices it will use the cordova plugin.
|
|
*
|
|
* @param url URL of the request.
|
|
* @param options Options for the request.
|
|
* @return Promise resolved with the response.
|
|
*/
|
|
async sendHTTPRequest(url: string, options: HttpRequestOptions): Promise<HttpResponse<any>> {
|
|
|
|
// Set default values.
|
|
options.responseType = options.responseType || 'json';
|
|
options.timeout = typeof options.timeout == 'undefined' ? this.getRequestTimeout() : options.timeout;
|
|
|
|
if (this.appProvider.isMobile()) {
|
|
// Use the cordova plugin.
|
|
if (url.indexOf('file://') === 0) {
|
|
// We cannot load local files using the http native plugin. Use file provider instead.
|
|
const format = options.responseType == 'json' ? CoreFileProvider.FORMATJSON : CoreFileProvider.FORMATTEXT;
|
|
|
|
const content = await this.fileProvider.readFile(url, format);
|
|
|
|
return new HttpResponse({
|
|
body: content,
|
|
headers: null,
|
|
status: 200,
|
|
statusText: 'OK',
|
|
url: url
|
|
});
|
|
}
|
|
|
|
return new Promise<HttpResponse<any>>((resolve, reject): void => {
|
|
// We cannot use Ionic Native plugin because it doesn't have the sendRequest method.
|
|
(<any> cordova).plugin.http.sendRequest(url, options, (response) => {
|
|
resolve(new CoreNativeToAngularHttpResponse(response));
|
|
}, reject);
|
|
});
|
|
} else {
|
|
let observable: Observable<any>;
|
|
|
|
// Use Angular's library.
|
|
switch (options.method) {
|
|
case 'get':
|
|
observable = this.http.get(url, {
|
|
headers: options.headers,
|
|
params: options.params,
|
|
observe: 'response',
|
|
responseType: <any> options.responseType,
|
|
});
|
|
break;
|
|
|
|
case 'post':
|
|
if (options.serializer == 'json') {
|
|
options.data = JSON.stringify(options.data);
|
|
}
|
|
|
|
observable = this.http.post(url, options.data, {
|
|
headers: options.headers,
|
|
observe: 'response',
|
|
responseType: <any> options.responseType,
|
|
});
|
|
break;
|
|
|
|
case 'head':
|
|
observable = this.http.head(url, {
|
|
headers: options.headers,
|
|
observe: 'response',
|
|
responseType: <any> options.responseType
|
|
});
|
|
break;
|
|
|
|
default:
|
|
return Promise.reject('Method not implemented yet.');
|
|
}
|
|
|
|
if (options.timeout) {
|
|
observable = observable.timeout(options.timeout);
|
|
}
|
|
|
|
return observable.toPromise();
|
|
}
|
|
}
|
|
}
|
|
|
|
export class CoreWS extends makeSingleton(CoreWSProvider) {}
|
|
|
|
/**
|
|
* Error returned by a WS call.
|
|
*/
|
|
export interface CoreWSError {
|
|
/**
|
|
* The error message.
|
|
*/
|
|
message: string;
|
|
|
|
/**
|
|
* Name of the exception. Undefined for local errors (fake WS errors).
|
|
*/
|
|
exception?: string;
|
|
|
|
/**
|
|
* The error code. Undefined for local errors (fake WS errors).
|
|
*/
|
|
errorcode?: string;
|
|
}
|
|
|
|
/**
|
|
* File upload options.
|
|
*/
|
|
export interface CoreWSFileUploadOptions extends FileUploadOptions {
|
|
/**
|
|
* The file area where to put the file. By default, 'draft'.
|
|
*/
|
|
fileArea?: string;
|
|
|
|
/**
|
|
* Item ID of the area where to put the file. By default, 0.
|
|
*/
|
|
itemId?: number;
|
|
}
|
|
|
|
/**
|
|
* Structure of warnings returned by WS.
|
|
*/
|
|
export type CoreWSExternalWarning = {
|
|
/**
|
|
* Item.
|
|
*/
|
|
item?: string;
|
|
|
|
/**
|
|
* Item id.
|
|
*/
|
|
itemid?: number;
|
|
|
|
/**
|
|
* The warning code can be used by the client app to implement specific behaviour.
|
|
*/
|
|
warningcode: string;
|
|
|
|
/**
|
|
* Untranslated english message to explain the warning.
|
|
*/
|
|
message: string;
|
|
|
|
};
|
|
|
|
/**
|
|
* Structure of files returned by WS.
|
|
*/
|
|
export type CoreWSExternalFile = {
|
|
/**
|
|
* File name.
|
|
*/
|
|
filename?: string;
|
|
|
|
/**
|
|
* File path.
|
|
*/
|
|
filepath?: string;
|
|
|
|
/**
|
|
* File size.
|
|
*/
|
|
filesize?: number;
|
|
|
|
/**
|
|
* Downloadable file url.
|
|
*/
|
|
fileurl?: string;
|
|
|
|
/**
|
|
* Time modified.
|
|
*/
|
|
timemodified?: number;
|
|
|
|
/**
|
|
* File mime type.
|
|
*/
|
|
mimetype?: string;
|
|
|
|
/**
|
|
* Whether is an external file.
|
|
*/
|
|
isexternalfile?: number;
|
|
|
|
/**
|
|
* The repository type for external files.
|
|
*/
|
|
repositorytype?: string;
|
|
|
|
};
|
|
|
|
/**
|
|
* Data returned by date_exporter.
|
|
*/
|
|
export type CoreWSDate = {
|
|
seconds: number; // Seconds.
|
|
minutes: number; // Minutes.
|
|
hours: number; // Hours.
|
|
mday: number; // Mday.
|
|
wday: number; // Wday.
|
|
mon: number; // Mon.
|
|
year: number; // Year.
|
|
yday: number; // Yday.
|
|
weekday: string; // Weekday.
|
|
month: string; // Month.
|
|
timestamp: number; // Timestamp.
|
|
};
|