580 lines
22 KiB
TypeScript
580 lines
22 KiB
TypeScript
// (C) Copyright 2015 Martin Dougiamas
|
|
//
|
|
// 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 { Platform } from 'ionic-angular';
|
|
import { CoreAppProvider } from '@providers/app';
|
|
import { CoreFilepoolProvider } from '@providers/filepool';
|
|
import { CoreLangProvider } from '@providers/lang';
|
|
import { CoreLoggerProvider } from '@providers/logger';
|
|
import { CoreSite, CoreSiteWSPreSets } from '@classes/site';
|
|
import { CoreSitesProvider } from '@providers/sites';
|
|
import { CoreTextUtilsProvider } from '@providers/utils/text';
|
|
import { CoreUtilsProvider, PromiseDefer } from '@providers/utils/utils';
|
|
import { CoreConfigConstants } from '../../../configconstants';
|
|
import { CoreCoursesProvider } from '@core/courses/providers/courses';
|
|
import { CoreEventsProvider } from '@providers/events';
|
|
|
|
/**
|
|
* Handler of a site plugin.
|
|
*/
|
|
export interface CoreSitePluginsHandler {
|
|
/**
|
|
* The site plugin data.
|
|
* @type {any}
|
|
*/
|
|
plugin: any;
|
|
|
|
/**
|
|
* Name of the handler.
|
|
* @type {string}
|
|
*/
|
|
handlerName: string;
|
|
|
|
/**
|
|
* Data of the handler.
|
|
* @type {any}
|
|
*/
|
|
handlerSchema: any;
|
|
|
|
/**
|
|
* Result of the init WS call.
|
|
* @type {any}
|
|
*/
|
|
initResult?: any;
|
|
}
|
|
|
|
/**
|
|
* Service to provide functionalities regarding site plugins.
|
|
*/
|
|
@Injectable()
|
|
export class CoreSitePluginsProvider {
|
|
static COMPONENT = 'CoreSitePlugins';
|
|
|
|
protected ROOT_CACHE_KEY = 'CoreSitePlugins:';
|
|
|
|
protected logger;
|
|
protected sitePlugins: {[name: string]: CoreSitePluginsHandler} = {}; // Site plugins registered.
|
|
protected sitePluginPromises: {[name: string]: Promise<any>} = {}; // Promises of loading plugins.
|
|
protected fetchPluginsDeferred: PromiseDefer;
|
|
hasSitePluginsLoaded = false;
|
|
sitePluginsFinishedLoading = false;
|
|
|
|
constructor(logger: CoreLoggerProvider, private sitesProvider: CoreSitesProvider, private utils: CoreUtilsProvider,
|
|
private langProvider: CoreLangProvider, private appProvider: CoreAppProvider, private platform: Platform,
|
|
private filepoolProvider: CoreFilepoolProvider, private coursesProvider: CoreCoursesProvider,
|
|
private textUtils: CoreTextUtilsProvider, private eventsProvider: CoreEventsProvider) {
|
|
this.logger = logger.getInstance('CoreUserProvider');
|
|
|
|
const observer = this.eventsProvider.on(CoreEventsProvider.SITE_PLUGINS_LOADED, () => {
|
|
this.sitePluginsFinishedLoading = true;
|
|
observer && observer.off();
|
|
});
|
|
|
|
// Initialize deferred at start and on logout.
|
|
this.fetchPluginsDeferred = this.utils.promiseDefer();
|
|
eventsProvider.on(CoreEventsProvider.LOGOUT, () => {
|
|
this.fetchPluginsDeferred = this.utils.promiseDefer();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Add some params that will always be sent for get content.
|
|
*
|
|
* @param {any} args Original params.
|
|
* @param {CoreSite} [site] Site. If not defined, current site.
|
|
* @return {Promise<any>} Promise resolved with the new params.
|
|
*/
|
|
protected addDefaultArgs(args: any, site?: CoreSite): Promise<any> {
|
|
args = args || {};
|
|
site = site || this.sitesProvider.getCurrentSite();
|
|
|
|
return this.langProvider.getCurrentLanguage().then((lang) => {
|
|
|
|
// Clone the object so the original one isn't modified.
|
|
const argsToSend = this.utils.clone(args);
|
|
|
|
argsToSend.userid = args.userid || site.getUserId();
|
|
argsToSend.appid = CoreConfigConstants.app_id;
|
|
argsToSend.appversioncode = CoreConfigConstants.versioncode;
|
|
argsToSend.appversionname = CoreConfigConstants.versionname;
|
|
argsToSend.applang = lang;
|
|
argsToSend.appcustomurlscheme = CoreConfigConstants.customurlscheme;
|
|
argsToSend.appisdesktop = this.appProvider.isDesktop();
|
|
argsToSend.appismobile = this.appProvider.isMobile();
|
|
argsToSend.appiswide = this.appProvider.isWide();
|
|
|
|
if (argsToSend.appisdevice) {
|
|
if (this.platform.is('ios')) {
|
|
argsToSend.appplatform = 'ios';
|
|
} else {
|
|
argsToSend.appplatform = 'android';
|
|
}
|
|
} else if (argsToSend.appisdesktop) {
|
|
if (this.appProvider.isMac()) {
|
|
argsToSend.appplatform = 'mac';
|
|
} else if (this.appProvider.isLinux()) {
|
|
argsToSend.appplatform = 'linux';
|
|
} else {
|
|
argsToSend.appplatform = 'windows';
|
|
}
|
|
} else {
|
|
argsToSend.appplatform = 'browser';
|
|
}
|
|
|
|
return argsToSend;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Call a WS for a site plugin.
|
|
*
|
|
* @param {string} method WS method to use.
|
|
* @param {any} data Data to send to the WS.
|
|
* @param {CoreSiteWSPreSets} [preSets] Extra options.
|
|
* @param {string} [siteId] Site ID. If not defined, current site.
|
|
* @return {Promise<any>} Promise resolved with the response.
|
|
*/
|
|
callWS(method: string, data: any, preSets?: CoreSiteWSPreSets, siteId?: string): Promise<any> {
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
preSets = preSets || {};
|
|
preSets.cacheKey = preSets.cacheKey || this.getCallWSCacheKey(method, data);
|
|
|
|
return site.read(method, data, preSets);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Given the result of a init get_content and, optionally, the result of another get_content,
|
|
* build an object with the data to pass to the JS of the get_content.
|
|
*
|
|
* @param {any} initResult Result of the init WS call.
|
|
* @param {any} [contentResult] Result of the content WS call (if any).
|
|
* @return {any} An object with the data to pass to the JS.
|
|
*/
|
|
createDataForJS(initResult: any, contentResult?: any): any {
|
|
let data;
|
|
|
|
if (initResult) {
|
|
// First of all, add the data returned by the init JS (if any).
|
|
data = this.utils.clone(initResult.jsResult || {});
|
|
if (typeof data == 'boolean') {
|
|
data = {};
|
|
}
|
|
|
|
// Now add some data returned by the init WS call.
|
|
data.INIT_TEMPLATES = this.utils.objectToKeyValueMap(initResult.templates, 'id', 'html');
|
|
data.INIT_OTHERDATA = initResult.otherdata;
|
|
}
|
|
|
|
if (contentResult) {
|
|
// Now add the data returned by the content WS call.
|
|
data.CONTENT_TEMPLATES = this.utils.objectToKeyValueMap(contentResult.templates, 'id', 'html');
|
|
data.CONTENT_OTHERDATA = contentResult.otherdata;
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* Get cache key for a WS call.
|
|
*
|
|
* @param {string} method Name of the method.
|
|
* @param {any} data Data to identify the WS call.
|
|
* @return {string} Cache key.
|
|
*/
|
|
getCallWSCacheKey(method: string, data: any): string {
|
|
return this.getCallWSCommonCacheKey(method) + ':' + this.utils.sortAndStringify(data);
|
|
}
|
|
|
|
/**
|
|
* Get common cache key for a WS call.
|
|
*
|
|
* @param {string} method Name of the method.
|
|
* @return {string} Cache key.
|
|
*/
|
|
protected getCallWSCommonCacheKey(method: string): string {
|
|
return this.ROOT_CACHE_KEY + 'ws:' + method;
|
|
}
|
|
|
|
/**
|
|
* Get a certain content for a site plugin.
|
|
*
|
|
* @param {string} component Component where the class is. E.g. mod_assign.
|
|
* @param {string} method Method to execute in the class.
|
|
* @param {any} args The params for the method.
|
|
* @param {CoreSiteWSPreSets} [preSets] Extra options.
|
|
* @param {string} [siteId] Site ID. If not defined, current site.
|
|
* @return {Promise<any>} Promise resolved with the result.
|
|
*/
|
|
getContent(component: string, method: string, args: any, preSets?: CoreSiteWSPreSets, siteId?: string): Promise<any> {
|
|
this.logger.debug(`Get content for component '${component}' and method '${method}'`);
|
|
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
|
|
// Add some params that will always be sent.
|
|
return this.addDefaultArgs(args, site).then((argsToSend) => {
|
|
// Now call the WS.
|
|
const data = {
|
|
component: component,
|
|
method: method,
|
|
args: this.utils.objectToArrayOfObjects(argsToSend, 'name', 'value', true)
|
|
};
|
|
|
|
preSets = preSets || {};
|
|
preSets.cacheKey = this.getContentCacheKey(component, method, args);
|
|
preSets.updateFrequency = typeof preSets.updateFrequency != 'undefined' ? preSets.updateFrequency :
|
|
CoreSite.FREQUENCY_OFTEN;
|
|
|
|
return this.sitesProvider.getCurrentSite().read('tool_mobile_get_content', data, preSets);
|
|
}).then((result) => {
|
|
if (result.otherdata) {
|
|
result.otherdata = this.utils.objectToKeyValueMap(result.otherdata, 'name', 'value');
|
|
|
|
// Try to parse all properties that could be JSON encoded strings.
|
|
for (const name in result.otherdata) {
|
|
const value = result.otherdata[name];
|
|
|
|
if (typeof value == 'string' && (value[0] == '{' || value[0] == '[')) {
|
|
result.otherdata[name] = this.textUtils.parseJSON(value);
|
|
}
|
|
}
|
|
} else {
|
|
result.otherdata = {};
|
|
}
|
|
|
|
return result;
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get cache key for get content WS calls.
|
|
*
|
|
* @param {string} component Component where the class is. E.g. mod_assign.
|
|
* @param {string} method Method to execute in the class.
|
|
* @param {any} args The params for the method.
|
|
* @return {string} Cache key.
|
|
*/
|
|
protected getContentCacheKey(component: string, method: string, args: any): string {
|
|
return this.ROOT_CACHE_KEY + 'content:' + component + ':' + method + ':' + this.utils.sortAndStringify(args);
|
|
}
|
|
|
|
/**
|
|
* Get the value of a WS param for prefetch.
|
|
*
|
|
* @param {string} component The component of the handler.
|
|
* @param {string} paramName Name of the param as defined by the handler.
|
|
* @param {number} [courseId] Course ID (if prefetching a course).
|
|
* @param {any} [module] The module object returned by WS (if prefetching a module).
|
|
* @return {any} The value.
|
|
*/
|
|
protected getDownloadParam(component: string, paramName: string, courseId?: number, module?: any): any {
|
|
switch (paramName) {
|
|
case 'courseids':
|
|
// The WS needs the list of course IDs. Create the list.
|
|
return [courseId];
|
|
|
|
case component + 'id':
|
|
// The WS needs the instance id.
|
|
return module && module.instance;
|
|
|
|
default:
|
|
// No more params supported for now.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the unique name of a handler (plugin + handler).
|
|
*
|
|
* @param {any} plugin Data of the plugin.
|
|
* @param {string} handlerName Name of the handler inside the plugin.
|
|
* @return {string} Unique name.
|
|
*/
|
|
getHandlerUniqueName(plugin: any, handlerName: string): string {
|
|
return plugin.addon + '_' + handlerName;
|
|
}
|
|
|
|
/**
|
|
* Get a site plugin handler.
|
|
*
|
|
* @param {string} name Unique name of the handler.
|
|
* @return {CoreSitePluginsHandler} Handler.
|
|
*/
|
|
getSitePluginHandler(name: string): CoreSitePluginsHandler {
|
|
return this.sitePlugins[name];
|
|
}
|
|
|
|
/**
|
|
* Invalidate all WS call to a certain method.
|
|
*
|
|
* @param {string} method WS method to use.
|
|
* @param {string} [siteId] Site ID. If not defined, current site.
|
|
* @return {Promise<any>} Promise resolved when the data is invalidated.
|
|
*/
|
|
invalidateAllCallWSForMethod(method: string, siteId?: string): Promise<any> {
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
return site.invalidateWsCacheForKeyStartingWith(this.getCallWSCommonCacheKey(method));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Invalidate a WS call.
|
|
*
|
|
* @param {string} method WS method to use.
|
|
* @param {any} data Data to send to the WS.
|
|
* @param {CoreSiteWSPreSets} [preSets] Extra options.
|
|
* @param {string} [siteId] Site ID. If not defined, current site.
|
|
* @return {Promise<any>} Promise resolved when the data is invalidated.
|
|
*/
|
|
invalidateCallWS(method: string, data: any, preSets?: CoreSiteWSPreSets, siteId?: string): Promise<any> {
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
return site.invalidateWsCacheForKey(preSets.cacheKey || this.getCallWSCacheKey(method, data));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Invalidate a page content.
|
|
*
|
|
* @param {string} component Component where the class is. E.g. mod_assign.
|
|
* @param {string} method Method to execute in the class.
|
|
* @param {any} args The params for the method.
|
|
* @param {string} [siteId] Site ID. If not defined, current site.
|
|
* @return {Promise<any>} Promise resolved when the data is invalidated.
|
|
*/
|
|
invalidateContent(component: string, callback: string, args: any, siteId?: string): Promise<any> {
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
return site.invalidateWsCacheForKey(this.getContentCacheKey(component, callback, args));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Check if the get content WS is available.
|
|
*
|
|
* @param {CoreSite} site The site to check. If not defined, current site.
|
|
*/
|
|
isGetContentAvailable(site?: CoreSite): boolean {
|
|
site = site || this.sitesProvider.getCurrentSite();
|
|
|
|
return site.wsAvailable('tool_mobile_get_content');
|
|
}
|
|
|
|
/**
|
|
* Check if a handler is enabled for a certain course.
|
|
*
|
|
* @param {number} courseId Course ID to check.
|
|
* @param {boolean} [restrictEnrolled] If true or undefined, handler is only enabled for courses the user is enrolled in.
|
|
* @param {any} [restrict] Users and courses the handler is restricted to.
|
|
* @return {boolean | Promise<boolean>} Whether the handler is enabled.
|
|
*/
|
|
isHandlerEnabledForCourse(courseId: number, restrictEnrolled?: boolean, restrict?: any): boolean | Promise<boolean> {
|
|
if (restrict && restrict.courses && restrict.courses.indexOf(courseId) == -1) {
|
|
// Course is not in the list of restricted courses.
|
|
return false;
|
|
}
|
|
|
|
if (restrictEnrolled || typeof restrictEnrolled == 'undefined') {
|
|
// Only enabled for courses the user is enrolled to. Check if the user is enrolled in the course.
|
|
return this.coursesProvider.getUserCourse(courseId, true).then(() => {
|
|
return true;
|
|
}).catch(() => {
|
|
return false;
|
|
});
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Check if a handler is enabled for a certain user.
|
|
*
|
|
* @param {number} userId User ID to check.
|
|
* @param {boolean} [restrictCurrent] Whether handler is only enabled for current user.
|
|
* @param {any} [restrict] Users and courses the handler is restricted to.
|
|
* @return {boolean} Whether the handler is enabled.
|
|
*/
|
|
isHandlerEnabledForUser(userId: number, restrictCurrent?: boolean, restrict?: any): boolean {
|
|
if (restrictCurrent && userId != this.sitesProvider.getCurrentSite().getUserId()) {
|
|
// Only enabled for current user.
|
|
return false;
|
|
}
|
|
|
|
if (restrict && restrict.users && restrict.users.indexOf(userId) == -1) {
|
|
// User is not in the list of restricted users.
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Load other data into args as determined by useOtherData list.
|
|
* If useOtherData is undefined, it won't add any data.
|
|
* If useOtherData is defined but empty (null, false or empty string) it will copy all the data from otherData to args.
|
|
* If useOtherData is an array, it will only copy the properties whose names are in the array.
|
|
*
|
|
* @param {any} args The current args.
|
|
* @param {any} otherData All the other data.
|
|
* @param {any[]} useOtherData Names of the attributes to include.
|
|
* @return {any} New args.
|
|
*/
|
|
loadOtherDataInArgs(args: any, otherData: any, useOtherData: any[]): any {
|
|
if (!args) {
|
|
args = {};
|
|
} else {
|
|
args = this.utils.clone(args);
|
|
}
|
|
|
|
otherData = otherData || {};
|
|
|
|
if (typeof useOtherData == 'undefined') {
|
|
// No need to add other data, return args as they are.
|
|
return args;
|
|
} else if (!useOtherData) {
|
|
// Use other data is defined but empty. Add all the data to args.
|
|
for (const name in otherData) {
|
|
args[name] = otherData[name];
|
|
}
|
|
} else {
|
|
for (const i in useOtherData) {
|
|
const name = useOtherData[i];
|
|
args[name] = otherData[name];
|
|
}
|
|
}
|
|
|
|
return args;
|
|
}
|
|
|
|
/**
|
|
* Prefetch offline functions for a site plugin handler.
|
|
*
|
|
* @param {string} component The component of the handler.
|
|
* @param {any} args Params to send to the get_content calls.
|
|
* @param {any} handlerSchema The handler schema.
|
|
* @param {number} [courseId] Course ID (if prefetching a course).
|
|
* @param {any} [module] The module object returned by WS (if prefetching a module).
|
|
* @param {boolean} [prefetch] True to prefetch, false to download right away.
|
|
* @param {string} [dirPath] Path of the directory where to store all the content files.
|
|
* @param {CoreSite} [site] Site. If not defined, current site.
|
|
* @return {Promise<any>} Promise resolved when done.
|
|
*/
|
|
prefetchFunctions(component: string, args: any, handlerSchema: any, courseId?: number, module?: any, prefetch?: boolean,
|
|
dirPath?: string, site?: CoreSite): Promise<any> {
|
|
site = site || this.sitesProvider.getCurrentSite();
|
|
|
|
const promises = [];
|
|
|
|
for (const method in handlerSchema.offlinefunctions) {
|
|
if (site.wsAvailable(method)) {
|
|
// The method is a WS.
|
|
const paramsList = handlerSchema.offlinefunctions[method],
|
|
cacheKey = this.getCallWSCacheKey(method, args);
|
|
let params = {};
|
|
|
|
if (!paramsList.length) {
|
|
// No params defined, send the default ones.
|
|
params = args;
|
|
} else {
|
|
for (const i in paramsList) {
|
|
const paramName = paramsList[i];
|
|
|
|
if (typeof args[paramName] != 'undefined') {
|
|
params[paramName] = args[paramName];
|
|
} else {
|
|
// The param is not one of the default ones. Try to calculate the param to use.
|
|
const value = this.getDownloadParam(component, paramName, courseId, module);
|
|
if (typeof value != 'undefined') {
|
|
params[paramName] = value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
promises.push(this.callWS(method, params, {cacheKey: cacheKey}));
|
|
} else {
|
|
// It's a method to get content.
|
|
promises.push(this.getContent(component, method, args).then((result) => {
|
|
const subPromises = [];
|
|
|
|
// Prefetch the files in the content.
|
|
if (result.files && result.files.length) {
|
|
subPromises.push(this.filepoolProvider.downloadOrPrefetchFiles(site.id, result.files, prefetch, false,
|
|
component, module.id, dirPath));
|
|
}
|
|
|
|
return Promise.all(subPromises);
|
|
}));
|
|
}
|
|
}
|
|
|
|
return Promise.all(promises);
|
|
}
|
|
|
|
/**
|
|
* Store a site plugin handler.
|
|
*
|
|
* @param {string} name A unique name to identify the handler.
|
|
* @param {CoreSitePluginsHandler} handler Handler to set.
|
|
*/
|
|
setSitePluginHandler(name: string, handler: CoreSitePluginsHandler): void {
|
|
this.sitePlugins[name] = handler;
|
|
}
|
|
|
|
/**
|
|
* Store the promise for a plugin that is being initialised.
|
|
*
|
|
* @param {String} component
|
|
* @param {Promise<any>} promise
|
|
*/
|
|
registerSitePluginPromise(component: string, promise: Promise<any>): void {
|
|
this.sitePluginPromises[component] = promise;
|
|
}
|
|
|
|
/**
|
|
* Set plugins fetched.
|
|
*/
|
|
setPluginsFetched(): void {
|
|
this.fetchPluginsDeferred.resolve();
|
|
}
|
|
|
|
/**
|
|
* Is a plugin being initialised for the specified component?
|
|
*
|
|
* @param {String} component
|
|
* @return {boolean}
|
|
*/
|
|
sitePluginPromiseExists(component: string): boolean {
|
|
return this.sitePluginPromises.hasOwnProperty(component);
|
|
}
|
|
|
|
/**
|
|
* Get the promise for a plugin that is being initialised.
|
|
*
|
|
* @param {String} component
|
|
* @return {Promise<any>}
|
|
*/
|
|
sitePluginLoaded(component: string): Promise<any> {
|
|
return this.sitePluginPromises[component];
|
|
}
|
|
|
|
/**
|
|
* Wait for fetch plugins to be done.
|
|
*
|
|
* @return {Promise<any>} Promise resolved when site plugins have been fetched.
|
|
*/
|
|
waitFetchPlugins(): Promise<any> {
|
|
return this.fetchPluginsDeferred.promise;
|
|
}
|
|
}
|