Esempio n. 1
0
        // Playlists <-> Song Mutations

        public async Task <UpdatePlaylistPayload> AddSongToPlaylistAsync
            (int playlistId, AddSongInput songInput, [Service] IPlaylistService playlistService)
        {
            var success = await playlistService.AddSongAsync(playlistId, songInput);

            return(new UpdatePlaylistPayload(success));
        }
Esempio n. 2
0
        // Song Mutations

        public async Task <AddSongPayload> AddSongAsync
        (
            AddSongInput input, [Service] ISongService songService
        )
        {
            var song = _mapper.Map <AddSongInput, Song>(input);
            await songService.CreateAsync(song);

            return(new AddSongPayload(song));
        }
        public async Task <bool> AddSongAsync(int playlistId, AddSongInput songInput)
        {
            var playlist = await GetByIdAsync(playlistId);

            // no playlist with given id
            if (playlist is null)
            {
                return(false);
            }

            var songInPlaylist =
                (
                    from song in playlist.Songs
                    where song.Name == songInput.Name &&
                    song.Artist == songInput.Artist &&
                    song.Type == songInput.Type
                    select song
                ).ToList();

            // song already in playlist
            if (songInPlaylist.Count > 0)
            {
                return(false);
            }

            var existingSong =
                (
                    from song in Context.Songs
                    where song.Name == songInput.Name &&
                    song.Artist == songInput.Artist &&
                    song.Type == songInput.Type
                    select song
                ).ToList();

            // song already in database
            if (existingSong.Count > 0)
            {
                playlist.Songs.Add(existingSong[0]);
                return(await Context.SaveChangesAsync() > 0);
            }

            // song not in database
            var newSong = _mapper.Map <AddSongInput, Song>(songInput);
            await Context.AddAsync(newSong);

            playlist.Songs.Add(newSong);
            return(await Context.SaveChangesAsync() > 0);
        }
Esempio n. 4
0
        public async Task <AddSongPayload> AddSongAsync(
            AddSongInput input,
            [ScopedService] DatabaseContext context,
            [Service] IAuthorization authorization,
            [Service] IFileStorage fileStorage,
            CancellationToken cancellationToken)
        {
            var song = new Song
            {
                Name   = input.Name,
                Artist = input.Artist
            };

            var songEntity = await context.Songs.AddAsync(song, cancellationToken);

            if (input.SongJacket != null)
            {
                var uploadTasks = new List <Task <string> >();
                try
                {
                    int[] imageSizes = { 32, 64, 128, 256, 512 };
                    using var ingredientImage = await Image.LoadAsync(input.SongJacket !.OpenReadStream());

                    foreach (var size in imageSizes)
                    {
                        var image = await Images.ImageToPngMemoryStream(ingredientImage, size, size);

                        var destinationKey = $"songs/{songEntity.Entity.Id}.{size}.png";
                        uploadTasks.Add(fileStorage.UploadFileFromStream(image, destinationKey));
                    }
                }
                catch
                {
                    return(new AddSongPayload(
                               new []
                    {
                        new UserError("Failed to upload song jacket.", CommonErrorCodes.IMAGE_UPLOAD_FAILED)
                    }
                               ));
                }

                var t = Task.WhenAll(uploadTasks);
                try
                {
                    t.Wait(cancellationToken);
                }
                catch
                {
                    return(new AddSongPayload(
                               new []
                    {
                        new UserError("Failed to upload song jacket.", CommonErrorCodes.IMAGE_UPLOAD_FAILED)
                    }
                               ));
                }
            }

            await context.SaveChangesAsync(cancellationToken);

            return(new AddSongPayload(songEntity.Entity));
        }