refactor(track-backend): refactor track backend code

src/backend/src/playlist/playlist.service.ts

@@ -5,12 +5,12 @@ import {PlaylistEntity} from "./playlist.entity";
 import {TrackService} from "../track/track.service";
 import {WebSocketGateway, WebSocketServer} from "@nestjs/websockets";
 import {Server} from "socket.io";
-import {TrackStatusEnum} from "../track/track.model";
 import {resolve} from "path";
 import {ConfigService} from "@nestjs/config";
 import {EnviromentEnum} from "../enviroment.enum";
 import * as fs from 'fs';
 import {Interval} from "@nestjs/schedule";
+import {TrackStatusEnum} from "../track/track.entity";
 const fetch = require('isomorphic-unfetch');
 const { getData, getPreview, getTracks, getDetails } = require('spotify-url-info')(fetch);
 
@@ -54,7 +54,7 @@ export class PlaylistService {
         for(let track of details?.tracks ?? []) {
             await this.trackService.create({
                 artist: track.artist,
-                song: track.name,
+                name: track.name,
                 spotifyUrl: track.previewUrl,
             }, savedPlaylist);
         }
@@ -100,7 +100,7 @@ export class PlaylistService {
             for(let track of details?.tracks ?? []) {
                 const track2Save = {
                     artist: track.artist,
-                    song: track.name,
+                    name: track.name,
                     spotifyUrl: track.previewUrl,
                 }
                 const isExist = !!(await this.trackService.findAll({...track2Save, playlist: {id: playlist.id}})).length;

src/backend/src/track/track.controller.ts

@@ -1,36 +1,41 @@
-import {Controller, Delete, Get, Param, Res, StreamableFile} from '@nestjs/common';
+import {
-import {TrackService} from "./track.service";
+  Controller,
-import {TrackModel} from "./track.model";
+  Delete,
-import {createReadStream} from "fs";
+  Get,
-import { resolve } from 'path';
+  Param,
+  Res,
+  StreamableFile,
+} from '@nestjs/common';
+import { TrackService } from './track.service';
+import { createReadStream } from 'fs';
 import type { Response } from 'express';
-import {ConfigService} from "@nestjs/config";
+import { ConfigService } from '@nestjs/config';
-import {EnviromentEnum} from "../enviroment.enum";
+import { TrackEntity } from './track.entity';
 
 @Controller('track')
 export class TrackController {
-
+  constructor(
-    constructor(private readonly service: TrackService,
+    private readonly service: TrackService,
-                private readonly configService: ConfigService) {
+    private readonly configService: ConfigService,
-    }
+  ) {}
-
-    @Get()
-    getAll(): Promise<TrackModel[]> {
-        return this.service.findAll();
-    }
 
   @Get('playlist/:id')
-    getAllByPlaylist(@Param('id') playlistId: number): Promise<TrackModel[]> {
+  getAllByPlaylist(@Param('id') playlistId: number): Promise<TrackEntity[]> {
     return this.service.getAllByPlaylist(playlistId);
   }
 
   @Get('download/:id')
-    async getFile(@Res({ passthrough: true }) res: Response, @Param('id') id: number): Promise<StreamableFile> {
+  async getFile(
+    @Res({ passthrough: true }) res: Response,
+    @Param('id') id: number,
+  ): Promise<StreamableFile> {
     const track = await this.service.findOne(id);
-        const fileName = `${track.artist} - ${track.song}.${this.configService.get<string>(EnviromentEnum.FORMAT)}`;
+    const fileName = this.service.getTrackFileName(track);
-        const filePath = createReadStream(resolve(__dirname, '..', this.configService.get<string>(EnviromentEnum.DOWNLOADS_PATH), track.playlist.name, fileName));
+    const readStream = createReadStream(
-        res.set({'Content-Disposition': `attachment; filename="${fileName}`});
+      this.service.getFolderName(track, track.playlist),
-        return new StreamableFile(filePath);
+    );
+    res.set({ 'Content-Disposition': `attachment; filename="${fileName}` });
+    return new StreamableFile(readStream);
   }
 
   @Delete(':id')

src/backend/src/track/track.entity.ts

@@ -1,10 +1,17 @@
-import {Entity, Column, PrimaryGeneratedColumn, ManyToOne, CreateDateColumn, UpdateDateColumn} from 'typeorm';
+import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from 'typeorm';
-import {PlaylistEntity} from "../playlist/playlist.entity";
+import { PlaylistEntity } from '../playlist/playlist.entity';
-import {TrackStatusEnum} from "./track.model";
+
+export enum TrackStatusEnum {
+  New,
+  Searching,
+  Queued,
+  Downloading,
+  Completed,
+  Error,
+}
 
 @Entity()
 export class TrackEntity {
-
   @PrimaryGeneratedColumn()
   id?: number;
 
@@ -12,7 +19,7 @@ export class TrackEntity {
   artist: string;
 
   @Column()
-    song: string;
+  name: string;
 
   @Column()
   spotifyUrl: string;
@@ -20,15 +27,17 @@ export class TrackEntity {
   @Column({ nullable: true })
   youtubeUrl?: string;
 
-    @Column({default: TrackStatusEnum.New})
+  @Column({ default: TrackStatusEnum.New })
   status?: TrackStatusEnum;
 
   @Column({ nullable: true })
   error?: string;
 
-    @Column({default: Date.now()})
+  @Column({ default: Date.now() })
   createdAt?: number;
 
-    @ManyToOne(() => PlaylistEntity, playlist => playlist.tracks, {onDelete: "CASCADE"})
+  @ManyToOne(() => PlaylistEntity, (playlist) => playlist.tracks, {
+    onDelete: 'CASCADE',
+  })
   playlist?: PlaylistEntity;
 }

src/backend/src/track/track.model.ts

@@ -1,22 +0,0 @@
-import {PlaylistModel} from "../playlist/playlist.model";
-
-export interface TrackModel {
-    id?: number;
-    artist: string;
-    song: string;
-    spotifyUrl: string;
-    youtubeUrl?: string;
-    status?: TrackStatusEnum,
-    playlist?: PlaylistModel;
-    createdAt?: number;
-    error?: string;
-}
-
-export enum TrackStatusEnum {
-    New,
-    Searching,
-    Queued,
-    Downloading,
-    Completed,
-    Error,
-}

src/backend/src/track/track.module.ts

@@ -1,15 +1,12 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
-import {TrackEntity} from "./track.entity";
+import { TrackEntity } from './track.entity';
-import {TrackService} from "./track.service";
+import { TrackService } from './track.service';
-import {TrackController} from "./track.controller";
+import { TrackController } from './track.controller';
-import {ConfigModule} from "@nestjs/config";
+import { ConfigModule } from '@nestjs/config';
 
 @Module({
-    imports: [
+  imports: [TypeOrmModule.forFeature([TrackEntity]), ConfigModule],
-        TypeOrmModule.forFeature([TrackEntity]),
-        ConfigModule,
-    ],
   providers: [TrackService],
   controllers: [TrackController],
   exports: [TrackService],

src/backend/src/track/track.service.ts

@@ -1,26 +1,30 @@
-import {Injectable} from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
-import {InjectRepository} from '@nestjs/typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
-import {Repository} from 'typeorm';
+import { Repository } from 'typeorm';
-import {TrackEntity} from "./track.entity";
+import { TrackEntity, TrackStatusEnum } from './track.entity';
-import {PlaylistEntity} from "../playlist/playlist.entity";
+import { PlaylistEntity } from '../playlist/playlist.entity';
-import {Interval} from "@nestjs/schedule";
+import { Interval } from '@nestjs/schedule';
-import {TrackStatusEnum} from "./track.model";
 import * as yts from 'yt-search';
-import {SearchResult} from 'yt-search';
 import * as ytdl from '@distube/ytdl-core';
 import * as fs from 'fs';
-import {ConfigService} from "@nestjs/config";
+import { ConfigService } from '@nestjs/config';
-import {resolve} from "path";
+import { resolve } from 'path';
-import {WebSocketGateway, WebSocketServer} from "@nestjs/websockets";
+import { WebSocketGateway, WebSocketServer } from '@nestjs/websockets';
-import {Server} from "socket.io";
+import { Server } from 'socket.io';
 import * as ffmpeg from 'fluent-ffmpeg';
-import {EnviromentEnum} from "../enviroment.enum";
+import { EnviromentEnum } from '../enviroment.enum';
+
+enum WsTrackOperation {
+  New = 'trackNew',
+  Update = 'trackUpdate',
+  Delete = 'trackDelete',
+}
 
 @WebSocketGateway()
 @Injectable()
 export class TrackService {
-
   @WebSocketServer() io: Server;
+  private readonly logger = new Logger(TrackService.name);
 
   constructor(
     @InjectRepository(TrackEntity)
@@ -28,97 +32,141 @@ export class TrackService {
     private readonly configService: ConfigService,
   ) {}
 
-    findAll(where?: {[key: string]: any}, relations: Record<string, boolean> = {}): Promise<TrackEntity[]> {
+  findAll(
-        return this.repository.find({where, relations});
+    where?: { [key: string]: any },
+    relations: Record<string, boolean> = {},
+  ): Promise<TrackEntity[]> {
+    return this.repository.find({ where, relations });
   }
 
   getAllByPlaylist(id: number): Promise<TrackEntity[]> {
-        return this.repository.find({where: {playlist: {id}}});
+    return this.repository.find({ where: { playlist: { id } } });
   }
 
   findOne(id: number): Promise<TrackEntity | null> {
-        return this.repository.findOne({where: {id}, relations: ['playlist']});
+    return this.repository.findOne({ where: { id }, relations: ['playlist'] });
   }
 
   async remove(id: number): Promise<void> {
     await this.repository.delete(id);
-        this.io.emit('trackDelete', {id});
+    this.io.emit(WsTrackOperation.Delete, { id });
   }
 
   async create(track: TrackEntity, playlist?: PlaylistEntity): Promise<void> {
-        const savedTrack = await this.repository.save({...track, playlist});
+    const savedTrack = await this.repository.save({ ...track, playlist });
-        this.io.emit('trackNew', {track: savedTrack, playlistId: playlist.id});
+    this.io.emit(WsTrackOperation.New, {
+      track: savedTrack,
+      playlistId: playlist.id,
+    });
   }
 
   async update(id: number, track: TrackEntity): Promise<void> {
     await this.repository.update(id, track);
-        this.io.emit('trackUpdate', track);
+    this.io.emit(WsTrackOperation.Update, track);
   }
 
   async retry(id: number): Promise<void> {
     const track = await this.findOne(id);
-        await this.update(id, {...track, status: TrackStatusEnum.New});
+    await this.update(id, { ...track, status: TrackStatusEnum.New });
   }
 
-    @Interval(1000)
+  @Interval(1_000)
-    async findOnYoutube() {
+  async findOnYoutube(): Promise<void> {
-        const newTracks = await this.findAll({status: TrackStatusEnum.New});
+    const newTracks = await this.findAll({ status: TrackStatusEnum.New });
-        for (let track of newTracks) {
+    await this.changeTracksStatuses(newTracks, TrackStatusEnum.Searching);
-            await this.update(track.id, {...track, status: TrackStatusEnum.Searching});
+    for (const track of newTracks) {
-        }
-        for(let track of newTracks) {
-            let youtubeResult: SearchResult;
       let updatedTrack: TrackEntity;
       try {
-                youtubeResult = await yts(`${track.artist} - ${track.song}`);
+        const youtubeResult = await yts(`${track.artist} - ${track.name}`);
-                updatedTrack = {...track, youtubeUrl: youtubeResult.videos[0].url, status: TrackStatusEnum.Queued};
+        updatedTrack = {
+          ...track,
+          youtubeUrl: youtubeResult.videos[0].url,
+          status: TrackStatusEnum.Queued,
+        };
       } catch (err) {
-                console.log(err);
+        this.logger.error(err);
-                updatedTrack = {...track, error: String(err), status: TrackStatusEnum.Error};
+        updatedTrack = {
+          ...track,
+          error: String(err),
+          status: TrackStatusEnum.Error,
+        };
       }
       await this.update(track.id, updatedTrack);
     }
   }
 
-    @Interval(1000)
+  @Interval(1_000)
-    async download() {
+  async downloadFromYoutube(): Promise<void> {
-        const queuedTracks = await this.findAll({status: TrackStatusEnum.Queued}, {playlist: true});
+    const queuedTracks = await this.findAll(
-        for (let track of queuedTracks) {
+      { status: TrackStatusEnum.Queued },
-            await this.update(track.id, {...track, status: TrackStatusEnum.Downloading});
+      { playlist: true },
-        }
+    );
-        for(let track of queuedTracks) {
+    await this.changeTracksStatuses(queuedTracks, TrackStatusEnum.Downloading);
+    for (const track of queuedTracks) {
       let error: string;
       try {
-                await this.youtubeDownload(track, track.playlist.name);
+        await this.downloadAndFormat(track, track.playlist);
-            } catch(err) {
+      } catch (err) {
-                console.log(err);
+        this.logger.error(err);
         error = String(err);
       }
       const updatedTrack = {
         ...track,
         status: error ? TrackStatusEnum.Error : TrackStatusEnum.Completed,
-                ...(error ? {error} : {}),
+        ...(error ? { error } : {}),
       };
       await this.update(track.id, updatedTrack);
     }
   }
 
-    private youtubeDownload(track: TrackEntity, playlistName: string): Promise<void> {
+  private downloadAndFormat(
+    track: TrackEntity,
+    playlist: PlaylistEntity,
+  ): Promise<void> {
+    const ffmpegOptions = [
+      '-metadata',
+      `title=${track.name}`,
+      '-metadata',
+      `artist=${track.artist}`,
+    ];
     return new Promise((res, reject) => {
-            const audio = ytdl(track.youtubeUrl, {quality: "highestaudio", filter: "audioonly"})
+      const audio = ytdl(track.youtubeUrl, {
-                .on('error', (err) => reject(err));
+        quality: 'highestaudio',
+        filter: 'audioonly',
+      }).on('error', (err) => reject(err));
       ffmpeg(audio)
-                .outputOptions('-metadata', `title=${track.song}`, '-metadata', `artist=${track.artist}`)
+        .outputOptions(ffmpegOptions)
         .format(this.configService.get<string>(EnviromentEnum.FORMAT))
         .on('error', (err) => reject(err))
         .pipe(
-                    fs.createWriteStream(
+          fs
-                        resolve(
+            .createWriteStream(this.getFolderName(track, playlist))
-                            __dirname, '..', this.configService.get<string>(EnviromentEnum.DOWNLOADS_PATH), playlistName,
+            .on('finish', () => res())
-                            `${track.artist} - ${track.song.replace('/', '')}.${this.configService.get<string>(EnviromentEnum.FORMAT)}`
+            .on('error', (err) => reject(err)),
-                        )
-                    ).on('finish', () => res()).on('error', (err) => reject(err))
         );
     });
   }
+
+  getTrackFileName(track: TrackEntity): string {
+    return `${track.artist} - ${track.name.replace('/', '')}.${this.configService.get<string>(EnviromentEnum.FORMAT)}`;
+  }
+
+  getFolderName(track: TrackEntity, playlist: PlaylistEntity): string {
+    return resolve(
+      __dirname,
+      '..',
+      this.configService.get<string>(EnviromentEnum.DOWNLOADS_PATH),
+      playlist.name,
+      this.getTrackFileName(track),
+    );
+  }
+
+  private async changeTracksStatuses(
+    tracks: TrackEntity[],
+    status: TrackStatusEnum,
+  ): Promise<void> {
+    for (const track of tracks) {
+      await this.update(track.id, { ...track, status });
+    }
+  }
 }

src/frontend/src/app/components/track-list/track-list.component.html

@@ -1,6 +1,6 @@
 <a class="panel-block is-flex is-justify-content-space-between" *ngFor="let track of tracks$ | async">
   <div>
-    <span>{{ track.artist }} - {{ track.song }}</span>&nbsp;
+    <span>{{ track.artist }} - {{ track.name }}</span>&nbsp;
     <a [href]="track.spotifyUrl"
        target="_blank"
        class="is-color-primary margin-left" title="Spotify preview of track that will be downloaded">

src/frontend/src/app/services/track.service.ts

@@ -12,7 +12,7 @@ const ENDPOINT = '/api/track';
 export interface Track {
   id: number;
   artist: string;
-  song: string;
+  name: string;
   spotifyUrl: string;
   youtubeUrl: string;
   status: TrackStatusEnum;