forked from EVOgeek/Vmeda.Online
181 lines
7.7 KiB
TypeScript
181 lines
7.7 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 { AlertController, ModalController } from 'ionic-angular';
|
|
import { TranslateService } from '@ngx-translate/core';
|
|
import { CoreAppProvider } from '@providers/app';
|
|
import { CoreFileProvider } from '@providers/file';
|
|
import { CoreLoggerProvider } from '@providers/logger';
|
|
import { CoreInitDelegate } from '@providers/init';
|
|
import { CoreSitesProvider } from '@providers/sites';
|
|
import { CoreDomUtilsProvider } from '@providers/utils/dom';
|
|
import { CoreUtilsProvider } from '@providers/utils/utils';
|
|
import { CoreSharedFilesProvider } from './sharedfiles';
|
|
import { CoreFileUploaderProvider } from '@core/fileuploader/providers/fileuploader';
|
|
|
|
/**
|
|
* Helper service to share files with the app.
|
|
*/
|
|
@Injectable()
|
|
export class CoreSharedFilesHelperProvider {
|
|
protected logger;
|
|
|
|
constructor(logger: CoreLoggerProvider, private alertCtrl: AlertController, private translate: TranslateService,
|
|
private utils: CoreUtilsProvider, private sitesProvider: CoreSitesProvider, private modalCtrl: ModalController,
|
|
private fileUploaderProvider: CoreFileUploaderProvider, private initDelegate: CoreInitDelegate,
|
|
private sharedFilesProvider: CoreSharedFilesProvider, private domUtils: CoreDomUtilsProvider,
|
|
private fileProvider: CoreFileProvider, private appProvider: CoreAppProvider) {
|
|
this.logger = logger.getInstance('CoreSharedFilesHelperProvider');
|
|
}
|
|
|
|
/**
|
|
* Ask a user if he wants to replace a file (using originalName) or rename it (using newName).
|
|
*
|
|
* @param {string} originalName Original name.
|
|
* @param {string} newName New name.
|
|
* @return {Promise<string>} Promise resolved with the name to use when the user chooses. Rejected if user cancels.
|
|
*/
|
|
askRenameReplace(originalName: string, newName: string): Promise<string> {
|
|
const deferred = this.utils.promiseDefer(),
|
|
alert = this.alertCtrl.create({
|
|
title: this.translate.instant('core.sharedfiles.sharedfiles'),
|
|
message: this.translate.instant('core.sharedfiles.chooseactionrepeatedfile', { $a: newName }),
|
|
buttons: [
|
|
{
|
|
text: this.translate.instant('core.sharedfiles.rename'),
|
|
handler: (): void => {
|
|
deferred.resolve(newName);
|
|
}
|
|
},
|
|
{
|
|
text: this.translate.instant('core.sharedfiles.replace'),
|
|
handler: (): void => {
|
|
deferred.resolve(originalName);
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
alert.present();
|
|
|
|
return deferred.promise;
|
|
}
|
|
|
|
/**
|
|
* Go to the choose site view.
|
|
*
|
|
* @param {string} filePath File path to send to the view.
|
|
*/
|
|
goToChooseSite(filePath: string): void {
|
|
const navCtrl = this.appProvider.getRootNavController();
|
|
navCtrl.push('CoreSharedFilesChooseSitePage', { filePath: filePath });
|
|
}
|
|
|
|
/**
|
|
* Open the view to select a shared file.
|
|
*
|
|
* @param {string[]} [mimetypes] List of supported mimetypes. If undefined, all mimetypes supported.
|
|
* @return {Promise<any>} Promise resolved when a file is picked, rejected if file picker is closed without selecting a file.
|
|
*/
|
|
pickSharedFile(mimetypes?: string[]): Promise<any> {
|
|
return new Promise((resolve, reject): void => {
|
|
const modal = this.modalCtrl.create('CoreSharedFilesListPage', { mimetypes: mimetypes, isModal: true, pick: true });
|
|
modal.present();
|
|
|
|
modal.onDidDismiss((file: any) => {
|
|
if (!file) {
|
|
// User cancelled.
|
|
reject();
|
|
|
|
return;
|
|
}
|
|
|
|
const error = this.fileUploaderProvider.isInvalidMimetype(mimetypes, file.fullPath);
|
|
if (error) {
|
|
reject(error);
|
|
} else {
|
|
resolve({
|
|
path: file.fullPath,
|
|
treated: false
|
|
});
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Checks if there is a new file received in iOS and move it to the shared folder of current site.
|
|
* If more than one site is found, the user will have to choose the site where to store it in.
|
|
* If more than one file is found, treat only the first one.
|
|
*
|
|
* @return {Promise<any>} Promise resolved when done.
|
|
*/
|
|
searchIOSNewSharedFiles(): Promise<any> {
|
|
return this.initDelegate.ready().then(() => {
|
|
const navCtrl = this.appProvider.getRootNavController();
|
|
if (navCtrl && navCtrl.getActive().id == 'CoreSharedFilesChooseSite') {
|
|
// We're already treating a shared file. Abort.
|
|
return Promise.reject(null);
|
|
}
|
|
|
|
return this.sharedFilesProvider.checkIOSNewFiles().then((fileEntry) => {
|
|
return this.sitesProvider.getSitesIds().then((siteIds) => {
|
|
if (!siteIds.length) {
|
|
// No sites stored, show error and delete the file.
|
|
this.domUtils.showErrorModal('core.sharedfiles.errorreceivefilenosites', true);
|
|
|
|
return this.sharedFilesProvider.deleteInboxFile(fileEntry);
|
|
} else if (siteIds.length == 1) {
|
|
return this.storeSharedFileInSite(fileEntry, siteIds[0]);
|
|
} else {
|
|
this.goToChooseSite(fileEntry.fullPath);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Store a shared file in a site's shared files folder.
|
|
*
|
|
* @param {any} fileEntry Shared file entry.
|
|
* @param {string} [siteId] Site ID. If not defined, current site.
|
|
* @return {Promise<any>} Promise resolved when done.
|
|
*/
|
|
storeSharedFileInSite(fileEntry: any, siteId?: string): Promise<any> {
|
|
siteId = siteId || this.sitesProvider.getCurrentSiteId();
|
|
|
|
// First of all check if there's already a file with the same name in the shared files folder.
|
|
const sharedFilesDirPath = this.sharedFilesProvider.getSiteSharedFilesDirPath(siteId);
|
|
|
|
return this.fileProvider.getUniqueNameInFolder(sharedFilesDirPath, fileEntry.name).then((newName) => {
|
|
if (newName == fileEntry.name) {
|
|
// No file with the same name. Use the original file name.
|
|
return newName;
|
|
} else {
|
|
// Repeated name. Ask the user what he wants to do.
|
|
return this.askRenameReplace(fileEntry.name, newName);
|
|
}
|
|
}).then((name) => {
|
|
return this.sharedFilesProvider.storeFileInSite(fileEntry, name, siteId).catch((err) => {
|
|
this.domUtils.showErrorModal(err || 'Error moving file.');
|
|
}).finally(() => {
|
|
this.sharedFilesProvider.deleteInboxFile(fileEntry);
|
|
this.domUtils.showAlertTranslated('core.success', 'core.sharedfiles.successstorefile');
|
|
});
|
|
});
|
|
}
|
|
}
|