498 lines
15 KiB
TypeScript
498 lines
15 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 { CoreSites } from '@services/sites';
|
|
import { CoreMimetypeUtils } from '@services/utils/mimetype';
|
|
import { CoreWSExternalWarning } from '@services/ws';
|
|
import { CoreSite } from '@classes/site';
|
|
import { makeSingleton } from '@singletons/core.singletons';
|
|
|
|
const ROOT_CACHE_KEY = 'mmaFiles:';
|
|
|
|
/**
|
|
* Service to handle my files and site files.
|
|
*/
|
|
@Injectable({
|
|
providedIn: 'root',
|
|
})
|
|
export class AddonPrivateFilesProvider {
|
|
|
|
// Keep old names for backwards compatibility.
|
|
static readonly PRIVATE_FILES_COMPONENT = 'mmaFilesMy';
|
|
static readonly SITE_FILES_COMPONENT = 'mmaFilesSite';
|
|
|
|
/**
|
|
* Check if core_user_get_private_files_info WS call is available.
|
|
*
|
|
* @return Whether the WS is available, false otherwise.
|
|
*/
|
|
canGetPrivateFilesInfo(): boolean {
|
|
return CoreSites.instance.wsAvailableInCurrentSite('core_user_get_private_files_info');
|
|
}
|
|
|
|
/**
|
|
* Check if user can view his private files.
|
|
*
|
|
* @return Whether the user can view his private files.
|
|
*/
|
|
canViewPrivateFiles(): boolean {
|
|
const currentSite = CoreSites.instance.getCurrentSite();
|
|
if (!currentSite) {
|
|
return false;
|
|
}
|
|
|
|
return currentSite.canAccessMyFiles() && !this.isPrivateFilesDisabledInSite();
|
|
}
|
|
|
|
/**
|
|
* Check if user can view site files.
|
|
*
|
|
* @return Whether the user can view site files.
|
|
*/
|
|
canViewSiteFiles(): boolean {
|
|
return !this.isSiteFilesDisabledInSite();
|
|
}
|
|
|
|
/**
|
|
* Check if user can upload private files.
|
|
*
|
|
* @return Whether the user can upload private files.
|
|
*/
|
|
canUploadFiles(): boolean {
|
|
const currentSite = CoreSites.instance.getCurrentSite();
|
|
if (!currentSite) {
|
|
return false;
|
|
}
|
|
|
|
return currentSite.canAccessMyFiles() && currentSite.canUploadFiles() && !this.isUploadDisabledInSite();
|
|
}
|
|
|
|
/**
|
|
* Get the list of files.
|
|
*
|
|
* @param params A list of parameters accepted by the Web service.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved with the files.
|
|
*/
|
|
async getFiles(params: AddonPrivateFilesGetFilesWSParams, siteId?: string): Promise<AddonPrivateFilesFile[]> {
|
|
|
|
const site = await CoreSites.instance.getSite(siteId);
|
|
|
|
const preSets = {
|
|
cacheKey: this.getFilesListCacheKey(params),
|
|
updateFrequency: CoreSite.FREQUENCY_SOMETIMES,
|
|
};
|
|
|
|
const result: AddonPrivateFilesGetFilesWSResult = await site.read('core_files_get_files', params, preSets);
|
|
|
|
if (!result.files) {
|
|
return [];
|
|
}
|
|
|
|
return result.files.map((entry) => {
|
|
entry.fileurl = entry.url;
|
|
|
|
if (entry.isdir) {
|
|
entry.imgPath = CoreMimetypeUtils.instance.getFolderIcon();
|
|
} else {
|
|
entry.imgPath = CoreMimetypeUtils.instance.getFileIcon(entry.filename);
|
|
}
|
|
|
|
return entry;
|
|
});
|
|
|
|
}
|
|
|
|
/**
|
|
* Get cache key for file list WS calls.
|
|
*
|
|
* @param params Params of the WS.
|
|
* @return Cache key.
|
|
*/
|
|
protected getFilesListCacheKey(params: AddonPrivateFilesGetFilesWSParams): string {
|
|
const root = !params.component ? 'site' : 'my';
|
|
|
|
return ROOT_CACHE_KEY + 'list:' + root + ':' + params.contextid + ':' + params.filepath;
|
|
}
|
|
|
|
/**
|
|
* Get the private files of the current user.
|
|
*
|
|
* @return Promise resolved with the files.
|
|
*/
|
|
getPrivateFiles(): Promise<AddonPrivateFilesFile[]> {
|
|
return this.getFiles(this.getPrivateFilesRootParams());
|
|
}
|
|
|
|
/**
|
|
* Get params to get root private files directory.
|
|
*
|
|
* @return Params.
|
|
*/
|
|
protected getPrivateFilesRootParams(): AddonPrivateFilesGetFilesWSParams {
|
|
return {
|
|
contextid: -1,
|
|
component: 'user',
|
|
filearea: 'private',
|
|
contextlevel: 'user',
|
|
instanceid: CoreSites.instance.getCurrentSite()?.getUserId(),
|
|
itemid: 0,
|
|
filepath: '',
|
|
filename: '',
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get private files info.
|
|
*
|
|
* @param userId User ID. If not defined, current user in the site.
|
|
* @param siteId Site ID. If not defined, use current site.
|
|
* @return Promise resolved with the info.
|
|
*/
|
|
async getPrivateFilesInfo(userId?: number, siteId?: string): Promise<AddonPrivateFilesGetUserInfoWSResult> {
|
|
const site = await CoreSites.instance.getSite(siteId);
|
|
|
|
userId = userId || site.getUserId();
|
|
|
|
const params: AddonPrivateFilesGetUserInfoWSParams = {
|
|
userid: userId,
|
|
};
|
|
const preSets = {
|
|
cacheKey: this.getPrivateFilesInfoCacheKey(userId),
|
|
updateFrequency: CoreSite.FREQUENCY_SOMETIMES,
|
|
};
|
|
|
|
return site.read('core_user_get_private_files_info', params, preSets);
|
|
}
|
|
|
|
/**
|
|
* Get the cache key for private files info WS calls.
|
|
*
|
|
* @param userId User ID.
|
|
* @return Cache key.
|
|
*/
|
|
protected getPrivateFilesInfoCacheKey(userId: number): string {
|
|
return this.getPrivateFilesInfoCommonCacheKey() + ':' + userId;
|
|
}
|
|
|
|
/**
|
|
* Get the common part of the cache keys for private files info WS calls.
|
|
*
|
|
* @return Cache key.
|
|
*/
|
|
protected getPrivateFilesInfoCommonCacheKey(): string {
|
|
return ROOT_CACHE_KEY + 'privateInfo';
|
|
}
|
|
|
|
/**
|
|
* Get the site files.
|
|
*
|
|
* @return Promise resolved with the files.
|
|
*/
|
|
getSiteFiles(): Promise<AddonPrivateFilesFile[]> {
|
|
return this.getFiles(this.getSiteFilesRootParams());
|
|
}
|
|
|
|
/**
|
|
* Get params to get root site files directory.
|
|
*
|
|
* @return Params.
|
|
*/
|
|
protected getSiteFilesRootParams(): AddonPrivateFilesGetFilesWSParams {
|
|
return {
|
|
contextid: 0,
|
|
component: '',
|
|
filearea: '',
|
|
itemid: 0,
|
|
filepath: '',
|
|
filename: '',
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Invalidates list of files in a certain directory.
|
|
*
|
|
* @param root Root of the directory ('my' for private files, 'site' for site files).
|
|
* @param params Params to the directory.
|
|
* @param siteId Site ID. If not defined, use current site.
|
|
* @return Promise resolved when the data is invalidated.
|
|
*/
|
|
async invalidateDirectory(root?: 'my' | 'site', params?: AddonPrivateFilesGetFilesWSParams, siteId?: string): Promise<void> {
|
|
if (!root) {
|
|
return;
|
|
}
|
|
|
|
if (!params) {
|
|
if (root === 'site') {
|
|
params = this.getSiteFilesRootParams();
|
|
} else {
|
|
params = this.getPrivateFilesRootParams();
|
|
}
|
|
}
|
|
|
|
const site = await CoreSites.instance.getSite(siteId);
|
|
|
|
await site.invalidateWsCacheForKey(this.getFilesListCacheKey(params));
|
|
}
|
|
|
|
/**
|
|
* Invalidates private files info for all users.
|
|
*
|
|
* @param siteId Site ID. If not defined, use current site.
|
|
* @return Promise resolved when the data is invalidated.
|
|
*/
|
|
async invalidatePrivateFilesInfo(siteId?: string): Promise<void> {
|
|
const site = await CoreSites.instance.getSite(siteId);
|
|
|
|
await site.invalidateWsCacheForKeyStartingWith(this.getPrivateFilesInfoCommonCacheKey());
|
|
}
|
|
|
|
/**
|
|
* Invalidates private files info for a certain user.
|
|
*
|
|
* @param userId User ID. If not defined, current user in the site.
|
|
* @param siteId Site ID. If not defined, use current site.
|
|
* @return Promise resolved when the data is invalidated.
|
|
*/
|
|
async invalidatePrivateFilesInfoForUser(userId?: number, siteId?: string): Promise<void> {
|
|
const site = await CoreSites.instance.getSite(siteId);
|
|
|
|
await site.invalidateWsCacheForKey(this.getPrivateFilesInfoCacheKey(userId || site.getUserId()));
|
|
}
|
|
|
|
/**
|
|
* Check if Files is disabled in a certain site.
|
|
*
|
|
* @param siteId Site Id. If not defined, use current site.
|
|
* @return Promise resolved with true if disabled, rejected or resolved with false otherwise.
|
|
*/
|
|
async isDisabled(siteId?: string): Promise<boolean> {
|
|
const site = await CoreSites.instance.getSite(siteId);
|
|
|
|
return this.isDisabledInSite(site);
|
|
}
|
|
|
|
/**
|
|
* Check if Files is disabled in a certain site.
|
|
*
|
|
* @param site Site. If not defined, use current site.
|
|
* @return Whether it's disabled.
|
|
*/
|
|
isDisabledInSite(site: CoreSite): boolean {
|
|
site = site || CoreSites.instance.getCurrentSite();
|
|
|
|
return site.isFeatureDisabled('CoreMainMenuDelegate_AddonPrivateFiles');
|
|
}
|
|
|
|
/**
|
|
* Return whether or not the plugin is enabled.
|
|
*
|
|
* @return True if enabled, false otherwise.
|
|
*/
|
|
isPluginEnabled(): boolean {
|
|
return this.canViewPrivateFiles() || this.canViewSiteFiles() || this.canUploadFiles();
|
|
}
|
|
|
|
/**
|
|
* Check if private files is disabled in a certain site.
|
|
*
|
|
* @param siteId Site Id. If not defined, use current site.
|
|
* @return Promise resolved with true if disabled, rejected or resolved with false otherwise.
|
|
*/
|
|
async isPrivateFilesDisabled(siteId?: string): Promise<boolean> {
|
|
const site = await CoreSites.instance.getSite(siteId);
|
|
|
|
return this.isPrivateFilesDisabledInSite(site);
|
|
}
|
|
|
|
/**
|
|
* Check if private files is disabled in a certain site.
|
|
*
|
|
* @param site Site. If not defined, use current site.
|
|
* @return Whether it's disabled.
|
|
*/
|
|
isPrivateFilesDisabledInSite(site?: CoreSite): boolean {
|
|
site = site || CoreSites.instance.getCurrentSite();
|
|
|
|
return !!site && site.isFeatureDisabled('AddonPrivateFilesPrivateFiles');
|
|
}
|
|
|
|
/**
|
|
* Check if site files is disabled in a certain site.
|
|
*
|
|
* @param siteId Site Id. If not defined, use current site.
|
|
* @return Promise resolved with true if disabled, rejected or resolved with false otherwise.
|
|
*/
|
|
async isSiteFilesDisabled(siteId?: string): Promise<boolean> {
|
|
const site = await CoreSites.instance.getSite(siteId);
|
|
|
|
return this.isSiteFilesDisabledInSite(site);
|
|
}
|
|
|
|
/**
|
|
* Check if site files is disabled in a certain site.
|
|
*
|
|
* @param site Site. If not defined, use current site.
|
|
* @return Whether it's disabled.
|
|
*/
|
|
isSiteFilesDisabledInSite(site?: CoreSite): boolean {
|
|
site = site || CoreSites.instance.getCurrentSite();
|
|
|
|
return !!site && site.isFeatureDisabled('AddonPrivateFilesSiteFiles');
|
|
}
|
|
|
|
/**
|
|
* Check if upload files is disabled in a certain site.
|
|
*
|
|
* @param siteId Site Id. If not defined, use current site.
|
|
* @return Promise resolved with true if disabled, rejected or resolved with false otherwise.
|
|
*/
|
|
async isUploadDisabled(siteId?: string): Promise<boolean> {
|
|
const site = await CoreSites.instance.getSite(siteId);
|
|
|
|
return this.isUploadDisabledInSite(site);
|
|
}
|
|
|
|
/**
|
|
* Check if upload files is disabled in a certain site.
|
|
*
|
|
* @param site Site. If not defined, use current site.
|
|
* @return Whether it's disabled.
|
|
*/
|
|
isUploadDisabledInSite(site?: CoreSite): boolean {
|
|
site = site || CoreSites.instance.getCurrentSite();
|
|
|
|
return !!site && site.isFeatureDisabled('AddonPrivateFilesUpload');
|
|
}
|
|
|
|
/**
|
|
* Move a file from draft area to private files.
|
|
*
|
|
* @param draftId The draft area ID of the file.
|
|
* @param siteid ID of the site. If not defined, use current site.
|
|
* @return Promise resolved in success, rejected otherwise.
|
|
*/
|
|
async moveFromDraftToPrivate(draftId: number, siteId?: string): Promise<null> {
|
|
const params: AddonPrivateFilesAddUserPrivateFilesWSParams = {
|
|
draftid: draftId,
|
|
};
|
|
const preSets = {
|
|
responseExpected: false,
|
|
};
|
|
|
|
const site = await CoreSites.instance.getSite(siteId);
|
|
|
|
return site.write('core_user_add_user_private_files', params, preSets);
|
|
}
|
|
|
|
/**
|
|
* Check the Moodle version in order to check if upload files is working.
|
|
*
|
|
* @param siteId Site ID. If not defined, use current site.
|
|
* @return Promise resolved with true if WS is working, false otherwise.
|
|
*/
|
|
async versionCanUploadFiles(siteId?: string): Promise<boolean> {
|
|
const site = await CoreSites.instance.getSite(siteId);
|
|
|
|
// Upload private files doesn't work for Moodle 3.1.0 due to a bug.
|
|
return site.isVersionGreaterEqualThan('3.1.1');
|
|
}
|
|
|
|
}
|
|
|
|
export class AddonPrivateFiles extends makeSingleton(AddonPrivateFilesProvider) {}
|
|
|
|
/**
|
|
* File data returned by core_files_get_files.
|
|
*/
|
|
export type AddonPrivateFilesFile = {
|
|
contextid: number;
|
|
component: string;
|
|
filearea: string;
|
|
itemid: number;
|
|
filepath: string;
|
|
filename: string;
|
|
isdir: boolean;
|
|
url: string;
|
|
timemodified: number;
|
|
timecreated?: number; // Time created.
|
|
filesize?: number; // File size.
|
|
author?: string; // File owner.
|
|
license?: string; // File license.
|
|
} & AddonPrivateFilesFileCalculatedData;
|
|
|
|
/**
|
|
* Calculated data for AddonPrivateFilesFile.
|
|
*/
|
|
export type AddonPrivateFilesFileCalculatedData = {
|
|
fileurl: string; // File URL, using same name as CoreWSExternalFile.
|
|
imgPath?: string; // Path to file icon's image.
|
|
};
|
|
/**
|
|
* Params of WS core_files_get_files.
|
|
*/
|
|
export type AddonPrivateFilesGetFilesWSParams = {
|
|
contextid: number; // Context id Set to -1 to use contextlevel and instanceid.
|
|
component: string; // Component.
|
|
filearea: string; // File area.
|
|
itemid: number; // Associated id.
|
|
filepath: string; // File path.
|
|
filename: string; // File name.
|
|
modified?: number; // Timestamp to return files changed after this time.
|
|
contextlevel?: string; // The context level for the file location.
|
|
instanceid?: number; // The instance id for where the file is located.
|
|
};
|
|
|
|
/**
|
|
* Result of WS core_files_get_files.
|
|
*/
|
|
export type AddonPrivateFilesGetFilesWSResult = {
|
|
parents: {
|
|
contextid: number;
|
|
component: string;
|
|
filearea: string;
|
|
itemid: number;
|
|
filepath: string;
|
|
filename: string;
|
|
}[];
|
|
files: AddonPrivateFilesFile[];
|
|
};
|
|
|
|
/**
|
|
* Params of core_user_get_private_files_info WS.
|
|
*/
|
|
export type AddonPrivateFilesGetUserInfoWSParams = {
|
|
userid?: number; // Id of the user, default to current user.
|
|
};
|
|
|
|
/**
|
|
* Data returned by core_user_get_private_files_info WS.
|
|
*/
|
|
export type AddonPrivateFilesGetUserInfoWSResult = {
|
|
filecount: number; // Number of files in the area.
|
|
foldercount: number; // Number of folders in the area.
|
|
filesize: number; // Total size of the files in the area.
|
|
filesizewithoutreferences: number; // Total size of the area excluding file references.
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
/**
|
|
* Params of core_user_add_user_private_files WS.
|
|
*/
|
|
export type AddonPrivateFilesAddUserPrivateFilesWSParams = {
|
|
draftid: number; // Draft area id.
|
|
};
|