From 3455db8d71f02ddb5dca8e91a9cfe539317cfba6 Mon Sep 17 00:00:00 2001
From: raiper34 <raipergm34@gmail.com>
Date: Wed, 26 Jun 2024 23:00:01 +0200
Subject: [PATCH] fix asynchronous code

---
 spooty-be/src/playlist/playlist.controller.ts | 18 ++--------
 spooty-be/src/playlist/playlist.service.ts    | 17 +++++++--
 spooty-be/src/track/track.service.ts          | 36 +++++++++++--------
 3 files changed, 39 insertions(+), 32 deletions(-)

diff --git a/spooty-be/src/playlist/playlist.controller.ts b/spooty-be/src/playlist/playlist.controller.ts
index e730ca3..6099010 100644
--- a/spooty-be/src/playlist/playlist.controller.ts
+++ b/spooty-be/src/playlist/playlist.controller.ts
@@ -1,16 +1,13 @@
 import {Body, Controller, Get, Post} from '@nestjs/common';
-const fetch = require('isomorphic-unfetch');
-const { getData, getPreview, getTracks, getDetails } = require('spotify-url-info')(fetch);
 import {PlaylistService} from "./playlist.service";
 import {PlaylistModel} from "./playlist.model";
-import {TrackService} from "../track/track.service";
+import {PlaylistEntity} from "./playlist.entity";
 
 @Controller('playlist')
 export class PlaylistController {
 
     constructor(
         private readonly service: PlaylistService,
-        private readonly trackService: TrackService,
     ) {
     }
 
@@ -20,16 +17,7 @@ export class PlaylistController {
     }
 
     @Post()
-    async create(@Body() playlist: PlaylistModel): Promise<void> {
-        await getDetails(playlist.spotifyUrl).then(async details => {
-            const savedPlaylist = await this.service.create({...playlist, name: details.preview.title});
-            details.tracks.forEach(track => {
-                this.trackService.create({
-                    artist: track.artist,
-                    song: track.name,
-                    spotifyUrl: track.previewUrl,
-                }, savedPlaylist);
-            });
-        });
+    async create(@Body() playlist: PlaylistModel): Promise<PlaylistEntity> {
+        return await this.service.create(playlist);
     }
 }
\ No newline at end of file
diff --git a/spooty-be/src/playlist/playlist.service.ts b/spooty-be/src/playlist/playlist.service.ts
index ed577fc..8237ce8 100644
--- a/spooty-be/src/playlist/playlist.service.ts
+++ b/spooty-be/src/playlist/playlist.service.ts
@@ -2,12 +2,16 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import {PlaylistEntity} from "./playlist.entity";
+import {TrackService} from "../track/track.service";
+const fetch = require('isomorphic-unfetch');
+const { getData, getPreview, getTracks, getDetails } = require('spotify-url-info')(fetch);
 
 @Injectable()
 export class PlaylistService {
     constructor(
         @InjectRepository(PlaylistEntity)
         private repository: Repository<PlaylistEntity>,
+        private readonly trackService: TrackService,
     ) {}
 
     findAll(): Promise<PlaylistEntity[]> {
@@ -22,8 +26,17 @@ export class PlaylistService {
         await this.repository.delete(id);
     }
 
-    async create(track: PlaylistEntity): Promise<PlaylistEntity> {
-        return this.repository.save(track);
+    async create(playlist: PlaylistEntity): Promise<PlaylistEntity> {
+        const details = await getDetails(playlist.spotifyUrl);
+        const savedPlaylist = await this.repository.save({...playlist, name: details.preview.title});
+        for(let track of details.tracks) {
+            await this.trackService.create({
+                artist: track.artist,
+                song: track.name,
+                spotifyUrl: track.previewUrl,
+            }, savedPlaylist);
+        }
+        return savedPlaylist;
     }
 
     async update(id: number, track: PlaylistEntity): Promise<void> {
diff --git a/spooty-be/src/track/track.service.ts b/spooty-be/src/track/track.service.ts
index 678755d..224e29f 100644
--- a/spooty-be/src/track/track.service.ts
+++ b/spooty-be/src/track/track.service.ts
@@ -39,28 +39,34 @@ export class TrackService {
         await this.repository.update(id, track);
     }
 
-    @Interval(3000)
+    @Interval(10000)
     async findOnYoutube() {
         const newTracks = await this.findAll({status: TrackStatusEnum.New});
-        newTracks.forEach(async track => {
+        for(let track of newTracks) {
             const youtubeResult = await yts(`${track.artist} - ${track.song}`);
-            await this.update(track.id, {...track, youtubeUrl: youtubeResult.videos[0].url, status: TrackStatusEnum.Queued})
-        });
+            await this.update(track.id, {
+                ...track,
+                youtubeUrl: youtubeResult.videos[0].url,
+                status: TrackStatusEnum.Queued
+            });
+        }
     }
 
-    @Interval(3000)
+    @Interval(15000)
     async download() {
         const queuedTracks = await this.findAll({status: TrackStatusEnum.Queued});
-        queuedTracks.forEach(async track => {
-            await ytdl(track.youtubeUrl, {quality: "highestaudio", filter: "audioonly"}).pipe(
-                fs.createWriteStream(resolve(
-                    __dirname,
-                    '..',
-                    this.configService.get<string>('DOWNLOADS'),
-                    `${track.artist} - ${track.song.replace('/', '')}.mp3`,
-                ))
-            );
+        for(let track of queuedTracks) {
+            await this.youtubeDownload(track);
             await this.update(track.id, {...track, status: TrackStatusEnum.Completed})
-        });
+        }
+    }
+
+    private youtubeDownload(track: TrackEntity): Promise<void> {
+        return new Promise((res, _reject) =>
+            ytdl(track.youtubeUrl, {quality: "highestaudio", filter: "audioonly"}).pipe(
+                fs.createWriteStream(resolve(__dirname, '..', this.configService.get<string>('DOWNLOADS'), `${track.artist} - ${track.song.replace('/', '')}.mp3`))
+                    .on('finish', () => res())
+            )
+        );
     }
 }
\ No newline at end of file