Added methods to modify download state

Added missing optionalJwt calls in several routes
download-manager
Isaac Abadi 4 years ago
parent ecef8842ae
commit ebfa49240c

@ -1608,7 +1608,7 @@ app.post('/api/downloadFileFromServer', optionalJwt, async (req, res) => {
});
});
app.post('/api/downloadArchive', async (req, res) => {
app.post('/api/downloadArchive', optionalJwt, async (req, res) => {
let sub = req.body.sub;
let archive_dir = sub.archive;
@ -1643,7 +1643,7 @@ app.post('/api/uploadCookies', upload_multer.single('cookies'), async (req, res)
// Updater API calls
app.get('/api/updaterStatus', async (req, res) => {
app.get('/api/updaterStatus', optionalJwt, async (req, res) => {
let status = updaterStatus;
if (status) {
@ -1654,7 +1654,7 @@ app.get('/api/updaterStatus', async (req, res) => {
});
app.post('/api/updateServer', async (req, res) => {
app.post('/api/updateServer', optionalJwt, async (req, res) => {
let tag = req.body.tag;
updateServer(tag);
@ -1667,7 +1667,7 @@ app.post('/api/updateServer', async (req, res) => {
// API Key API calls
app.post('/api/generateNewAPIKey', function (req, res) {
app.post('/api/generateNewAPIKey', optionalJwt, function (req, res) {
const new_api_key = uuid();
config_api.setConfigItem('ytdl_api_key', new_api_key);
res.send({new_api_key: new_api_key});
@ -1739,12 +1739,12 @@ app.get('/api/thumbnail/:path', optionalJwt, async (req, res) => {
// Downloads management
app.get('/api/downloads', async (req, res) => {
app.get('/api/downloads', optionalJwt, async (req, res) => {
const downloads = await db_api.getRecords('download_queue');
res.send({downloads: downloads});
});
});
app.post('/api/download', async (req, res) => {
app.post('/api/download', optionalJwt, async (req, res) => {
const download_uid = req.body.download_uid;
const download = await db_api.getRecord('download_queue', {uid: download_uid});
@ -1754,15 +1754,46 @@ app.get('/api/thumbnail/:path', optionalJwt, async (req, res) => {
} else {
res.send({download: null});
}
});
});
app.post('/api/clearFinishedDownloads', optionalJwt, async (req, res) => {
const success = db_api.removeAllRecords('download_queue', {finished: true});
res.send({success: success});
});
app.post('/api/clearDownload', optionalJwt, async (req, res) => {
const download_uid = req.body.download_uid;
const success = await downloader_api.clearDownload(download_uid);
res.send({success: success});
});
app.post('/api/clearFinishedDownloads', async (req, res) => {
app.post('/api/pauseDownload', optionalJwt, async (req, res) => {
const download_uid = req.body.download_uid;
const success = await downloader_api.pauseDownload(download_uid);
res.send({success: success});
});
});
app.post('/api/resumeDownload', optionalJwt, async (req, res) => {
const download_uid = req.body.download_uid;
const success = await downloader_api.resumeDownload(download_uid);
res.send({success: success});
});
app.post('/api/restartDownload', optionalJwt, async (req, res) => {
const download_uid = req.body.download_uid;
const success = await downloader_api.restartDownload(download_uid);
res.send({success: success});
});
app.post('/api/cancelDownload', optionalJwt, async (req, res) => {
const download_uid = req.body.download_uid;
const success = await downloader_api.cancelDownload(download_uid);
res.send({success: success});
});
// logs management
app.post('/api/logs', async function(req, res) {
app.post('/api/logs', optionalJwt, async function(req, res) {
let logs = null;
let lines = req.body.lines;
const logs_path = path.join('appdata', 'logs', 'combined.log')
@ -1779,7 +1810,7 @@ app.post('/api/logs', async function(req, res) {
});
});
app.post('/api/clearAllLogs', async function(req, res) {
app.post('/api/clearAllLogs', optionalJwt, async function(req, res) {
const logs_path = path.join('appdata', 'logs', 'combined.log');
const logs_err_path = path.join('appdata', 'logs', 'error.log');
let success = false;
@ -1798,7 +1829,7 @@ app.post('/api/clearAllLogs', async function(req, res) {
});
});
app.post('/api/getFileFormats', async (req, res) => {
app.post('/api/getFileFormats', optionalJwt, async (req, res) => {
let url = req.body.url;
let result = await getUrlInfos(url);
res.send({

@ -15,22 +15,23 @@ const utils = require('./utils');
let db_api = null;
let downloads_setup_done = false;
const archivePath = path.join(__dirname, 'appdata', 'archives');
function setDB(input_db_api) { db_api = input_db_api }
exports.initialize = (input_db_api) => {
setDB(input_db_api);
setInterval(checkDownloads, 10000);
categories_api.initialize(db_api);
// temporary
db_api.removeAllRecords('download_queue');
setupDownloads();
}
exports.createDownload = async (url, type, options) => {
const download = {
url: url,
type: type,
title: '',
options: options,
uid: uuid(),
step_index: 0,
@ -45,15 +46,80 @@ exports.createDownload = async (url, type, options) => {
return download;
}
exports.pauseDownload = () => {
exports.pauseDownload = async (download_uid) => {
const download = await db_api.getRecord('download_queue', {uid: download_uid});
if (download['paused']) {
logger.warn(`Download ${download_uid} is already paused!`);
return false;
} else if (download['finished']) {
logger.info(`Download ${download_uid} could not be paused before completing.`);
return false;
}
return await db_api.updateRecord('download_queue', {uid: download_uid}, {paused: true});
}
exports.resumeDownload = async (download_uid) => {
const download = await db_api.getRecord('download_queue', {uid: download_uid});
if (!download['paused']) {
logger.warn(`Download ${download_uid} is not paused!`);
return false;
}
return await db_api.updateRecord('download_queue', {uid: download_uid}, {paused: false});
}
exports.restartDownload = async (download_uid) => {
const download = await db_api.getRecord('download_queue', {uid: download_uid});
await exports.clearDownload(download_uid);
const success = !!(await exports.createDownload(download['url'], download['type'], download['options']));
return success;
}
exports.cancelDownload = async (download_uid) => {
const download = await db_api.getRecord('download_queue', {uid: download_uid});
if (download['cancelled']) {
logger.warn(`Download ${download_uid} is already cancelled!`);
return false;
} else if (download['finished']) {
logger.info(`Download ${download_uid} could not be cancelled before completing.`);
return false;
}
return await db_api.updateRecord('download_queue', {uid: download_uid}, {cancelled: true});
}
exports.clearDownload = async (download_uid) => {
return await db_api.removeRecord('download_queue', {uid: download_uid});
}
// questions
// how do we want to manage queued downloads that errored in any step? do we set the index back and finished_step to true or let the manager do it?
async function setupDownloads() {
await fixDownloadState();
setInterval(checkDownloads, 10000);
}
async function fixDownloadState() {
const downloads = await db_api.getRecords('download_queue');
downloads.sort((download1, download2) => download1.timestamp_start - download2.timestamp_start);
const running_downloads = downloads.filter(download => !download['finished_step']);
for (let i = 0; i < running_downloads.length; i++) {
const running_download = running_downloads[i];
const update_obj = {finished_step: true, paused: true};
if (running_download['step_index'] > 0) {
update_obj['step_index'] = running_download['step_index'] - 1;
}
await db_api.updateRecord('download_queue', {uid: running_download['uid']}, update_obj);
}
}
async function checkDownloads() {
logger.verbose('Checking downloads');
if (!downloads_setup_done) {
await setupDownloads();
downloads_setup_done = true;
}
const downloads = await db_api.getRecords('download_queue');
downloads.sort((download1, download2) => download1.timestamp_start - download2.timestamp_start);
const running_downloads = downloads.filter(download => !download['paused'] && download['finished_step']);
@ -65,7 +131,6 @@ async function checkDownloads() {
// move to next step
if (running_download['step_index'] === 0) {
collectInfo(running_download['uid']);
} else if (running_download['step_index'] === 1) {
downloadQueuedFile(running_download['uid']);
@ -75,9 +140,12 @@ async function checkDownloads() {
}
async function collectInfo(download_uid) {
const download = await db_api.getRecord('download_queue', {uid: download_uid});
if (download['paused']) {
return;
}
logger.verbose(`Collecting info for download ${download_uid}`);
await db_api.updateRecord('download_queue', {uid: download_uid}, {step_index: 1, finished_step: false});
const download = await db_api.getRecord('download_queue', {uid: download_uid});
const url = download['url'];
const type = download['type'];
@ -127,21 +195,26 @@ async function collectInfo(download_uid) {
files_to_check_for_progress.push(utils.removeFileExtension(info['_filename']));
}
const playlist_title = Array.isArray(info) ? info[0]['playlist_title'] || info[0]['playlist'] : null;
await db_api.updateRecord('download_queue', {uid: download_uid}, {args: args,
finished_step: true,
options: options,
files_to_check_for_progress: files_to_check_for_progress,
expected_file_size: expected_file_size
expected_file_size: expected_file_size,
title: playlist_title ? playlist_title : info['title']
});
}
async function downloadQueuedFile(download_uid) {
const download = await db_api.getRecord('download_queue', {uid: download_uid});
if (download['paused']) {
return;
}
logger.verbose(`Downloading ${download_uid}`);
return new Promise(async resolve => {
const audioFolderPath = config_api.getConfigItem('ytdl_audio_folder_path');
const videoFolderPath = config_api.getConfigItem('ytdl_video_folder_path');
await db_api.updateRecord('download_queue', {uid: download_uid}, {step_index: 2, finished_step: false});
const download = await db_api.getRecord('download_queue', {uid: download_uid});
const url = download['url'];
const type = download['type'];

@ -16,7 +16,7 @@ const routes: Routes = [
{ path: 'subscription', component: SubscriptionComponent, canActivate: [PostsService] },
{ path: 'settings', component: SettingsComponent, canActivate: [PostsService] },
{ path: 'login', component: LoginComponent },
{ path: 'downloads', component: DownloadsComponent },
{ path: 'downloads', component: DownloadsComponent, canActivate: [PostsService] },
{ path: '', redirectTo: '/home', pathMatch: 'full' }
];

@ -12,8 +12,8 @@
<ng-container matColumnDef="title">
<mat-header-cell *matHeaderCellDef> <ng-container i18n="Title">Title</ng-container> </mat-header-cell>
<mat-cell *matCellDef="let element">
<span class="one-line" *ngIf="element.container">
{{element.container.title ? element?.container.title : element.container.name}}
<span class="one-line" [matTooltip]="element.title ? element.title : null">
{{element.title}}
</span>
</mat-cell>
</ng-container>
@ -27,7 +27,14 @@
<!-- Progress Column -->
<ng-container matColumnDef="progress">
<mat-header-cell *matHeaderCellDef> <ng-container i18n="Progress">Progress</ng-container> </mat-header-cell>
<mat-cell *matCellDef="let element"> {{+(element.percent_complete) > 100 ? '100' : element.percent_complete}}% </mat-cell>
<mat-cell *matCellDef="let element">
<ng-container *ngIf="element.percent_complete">
{{+(element.percent_complete) > 100 ? '100' : element.percent_complete}}%
</ng-container>
<ng-container *ngIf="!element.percent_complete">
N/A
</ng-container>
</mat-cell>
</ng-container>
<!-- Actions Column -->
@ -35,12 +42,14 @@
<mat-header-cell *matHeaderCellDef> <ng-container i18n="Actions">Actions</ng-container> </mat-header-cell>
<mat-cell *matCellDef="let element">
<div *ngIf="!element.finished">
<button mat-icon-button><mat-icon>pause</mat-icon></button>
<button mat-icon-button><mat-icon>cancel</mat-icon></button>
<button (click)="pauseDownload(element.uid)" *ngIf="!element.paused || !element.finished_step" [disabled]="element.paused && !element.finished_step" mat-icon-button matTooltip="Pause" i18n-matTooltip="Pause"><mat-spinner [diameter]="28" *ngIf="element.paused && !element.finished_step" class="icon-button-spinner"></mat-spinner><mat-icon>pause</mat-icon></button>
<button (click)="resumeDownload(element.uid)" *ngIf="element.paused && element.finished_step" mat-icon-button matTooltip="Resume" i18n-matTooltip="Resume"><mat-icon>play_arrow</mat-icon></button>
<button (click)="cancelDownload(element.uid)" mat-icon-button matTooltip="Cancel" i18n-matTooltip="Cancel"><mat-icon>cancel</mat-icon></button>
</div>
<div *ngIf="element.finished">
<button mat-icon-button><mat-icon>restart_alt</mat-icon></button>
<button mat-icon-button><mat-icon>delete</mat-icon></button>
<button (click)="watchContent(element)" mat-icon-button matTooltip="Watch content" i18n-matTooltip="Watch content"><mat-icon>smart_display</mat-icon></button>
<button (click)="restartDownload(element.uid)" mat-icon-button matTooltip="Restart" i18n-matTooltip="Restart"><mat-icon>restart_alt</mat-icon></button>
<button (click)="clearDownload(element.uid)" mat-icon-button matTooltip="Clear" i18n-matTooltip="Clear"><mat-icon>delete</mat-icon></button>
</div>
</mat-cell>
</ng-container>

@ -6,4 +6,10 @@ mat-header-cell, mat-cell {
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.icon-button-spinner {
position: absolute;
top: 7px;
left: 6px;
}

@ -48,7 +48,8 @@ export class DownloadsComponent implements OnInit, OnDestroy {
STEP_INDEX_TO_LABEL = {
0: 'Creating download',
1: 'Getting info',
2: 'Downloading file'
2: 'Downloading file',
3: 'Complete'
}
displayedColumns: string[] = ['date', 'title', 'stage', 'progress', 'actions'];
@ -57,25 +58,33 @@ export class DownloadsComponent implements OnInit, OnDestroy {
@ViewChild(MatPaginator) paginator: MatPaginator;
sort_downloads = (a, b) => {
const result = b.value.timestamp_start - a.value.timestamp_start;
const result = b.timestamp_start - a.timestamp_start;
return result;
}
constructor(public postsService: PostsService, private router: Router) { }
ngOnInit(): void {
if (this.postsService.initialized) {
this.getCurrentDownloadsRecurring();
} else {
this.postsService.service_initialized.subscribe(init => {
if (init) {
this.getCurrentDownloadsRecurring();
}
});
}
}
getCurrentDownloadsRecurring() {
if (!this.postsService.config['Extra']['enable_downloads_manager']) {
this.router.navigate(['/home']);
return;
}
this.getCurrentDownloads();
this.interval_id = setInterval(() => {
this.getCurrentDownloads();
}, this.downloads_check_interval);
this.postsService.service_initialized.subscribe(init => {
if (init) {
if (!this.postsService.config['Extra']['enable_downloads_manager']) {
this.router.navigate(['/home']);
}
}
});
}
ngOnDestroy(): void {
@ -88,6 +97,7 @@ export class DownloadsComponent implements OnInit, OnDestroy {
&& res['downloads'] !== undefined
&& JSON.stringify(this.downloads) !== JSON.stringify(res['downloads'])) {
this.downloads = res['downloads'];
this.downloads.sort(this.sort_downloads);
this.dataSource = new MatTableDataSource<Download>(this.downloads);
this.dataSource.paginator = this.paginator;
} else {
@ -97,13 +107,64 @@ export class DownloadsComponent implements OnInit, OnDestroy {
}
clearFinishedDownloads(): void {
this.postsService.clearDownloads(false).subscribe(res => {
if (res['success']) {
this.downloads = res['downloads'];
this.postsService.clearFinishedDownloads().subscribe(res => {
if (!res['success']) {
this.postsService.openSnackBar('Failed to clear finished downloads!');
}
});
}
pauseDownload(download_uid) {
this.postsService.pauseDownload(download_uid).subscribe(res => {
if (!res['success']) {
this.postsService.openSnackBar('Failed to pause download! See server logs for more info.');
}
});
}
resumeDownload(download_uid) {
this.postsService.resumeDownload(download_uid).subscribe(res => {
if (!res['success']) {
this.postsService.openSnackBar('Failed to resume download! See server logs for more info.');
}
});
}
restartDownload(download_uid) {
this.postsService.restartDownload(download_uid).subscribe(res => {
if (!res['success']) {
this.postsService.openSnackBar('Failed to restart download! See server logs for more info.');
}
});
}
cancelDownload(download_uid) {
this.postsService.cancelDownload(download_uid).subscribe(res => {
if (!res['success']) {
this.postsService.openSnackBar('Failed to cancel download! See server logs for more info.');
}
});
}
clearDownload(download_uid) {
this.postsService.clearDownload(download_uid).subscribe(res => {
if (!res['success']) {
this.postsService.openSnackBar('Failed to pause download! See server logs for more info.');
}
});
}
watchContent(download) {
const container = download['container'];
localStorage.setItem('player_navigator', this.router.url.split(';')[0]);
const is_playlist = container['uids']; // hacky, TODO: fix
if (is_playlist) {
this.router.navigate(['/player', {playlist_id: container['id'], type: download['type']}]);
} else {
this.router.navigate(['/player', {type: download['type'], uid: container['uid']}]);
}
}
}
export interface Download {

@ -413,24 +413,38 @@ export class PostsService implements CanActivate {
return this.http.post(this.path + 'getSubscriptions', {}, this.httpOptions);
}
// current downloads
getCurrentDownloads() {
return this.http.get(this.path + 'downloads', this.httpOptions);
}
// current download
getCurrentDownload(download_uid) {
return this.http.post(this.path + 'download', {download_uid: download_uid}, this.httpOptions);
}
// clear downloads. download_id is optional, if it exists only 1 download will be cleared
clearDownloads(delete_all = false, session_id = null, download_id = null) {
return this.http.post(this.path + 'clearDownloads', {delete_all: delete_all,
download_id: download_id,
session_id: session_id ? session_id : this.session_id}, this.httpOptions);
pauseDownload(download_uid) {
return this.http.post(this.path + 'pauseDownload', {download_uid: download_uid}, this.httpOptions);
}
resumeDownload(download_uid) {
return this.http.post(this.path + 'resumeDownload', {download_uid: download_uid}, this.httpOptions);
}
restartDownload(download_uid) {
return this.http.post(this.path + 'restartDownload', {download_uid: download_uid}, this.httpOptions);
}
cancelDownload(download_uid) {
return this.http.post(this.path + 'cancelDownload', {download_uid: download_uid}, this.httpOptions);
}
clearDownload(download_uid) {
return this.http.post(this.path + 'clearDownload', {download_uid: download_uid}, this.httpOptions);
}
clearFinishedDownloads() {
return this.http.post(this.path + 'clearFinishedDownloads', {}, this.httpOptions);
}
// updates the server to the latest version
updateServer(tag) {
return this.http.post(this.path + 'updateServer', {tag: tag}, this.httpOptions);
}

Loading…
Cancel
Save