Esempio n. 1
0
        public IHttpActionResult AddNewSong([FromBody] SongCreationModel songCreationModel)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            CreateSongRequest songRequest;

            try
            {
                songRequest = new CreateSongRequest(
                    songCreationModel.Name,
                    songCreationModel.Text,
                    songCreationModel.Artist);
            }
            catch (ArgumentException)
            {
                return(BadRequest("Fields must not be empty"));
            }
            int createdSongId;

            try
            {
                createdSongId = _musicManager.CreateSong(songRequest);
            }
            catch (AccountAlreadyExistsException ex)
            {
                return(Content(HttpStatusCode.Conflict, ex.Message));
            }
            return(Ok(createdSongId));
        }
Esempio n. 2
0
 public Song(CreateSongRequest req)
 {
     Name         = req.Name;
     ArtistId     = req.ArtistId;
     Audio        = req.Audio;
     CategoriesId = req.CategoriesId;
 }
Esempio n. 3
0
        public async Task <IActionResult> Post([FromBody] CreateSongRequest request)
        {
            if (request.Url == null || !request.Url.Authority.Contains("youtube.com"))
            {
                return(this.BadRequest("Uri is invalid"));
            }

            await _publisher.PublishAsync(new CreateSongCommand
            {
                Url   = request.Url.ToString(),
                Email = request.Email
            });

            return(this.Ok());
        }
Esempio n. 4
0
        public int CreateSong(CreateSongRequest request)
        {
            Require.NotNull(request, nameof(request));
            Artist artist = _musicRepository.GetArtists(a => a.Name.Equals(request.Artist)).SingleOrDefault();

            if (artist == null)
            {
                throw new AccountAlreadyExistsException("Artist not found");
            }
            var newSong = new Song(
                request.Name,
                request.Text,
                artist);
            var songId = _musicRepository.CreateSong(newSong);

            return(songId);
        }
        private async Task <int> NormalizeAudio(FileReference fileReference, CreateSongRequest requestBody, string authorName)
        {
            var oldId = fileReference._id;
            var newId = ObjectId.GenerateNewId();

            var gridFsBucket   = new GridFSBucket <ObjectId>(MongoWrapper.Database);
            var downloadStream = await gridFsBucket.OpenDownloadStreamAsync(oldId);

            (Stream newAudio, int seconds) = await AudioHandlerService.ProcessAudio
                                             (
                downloadStream,
                requestBody.Autoral?null : new int?(15),
                requestBody.Nome,
                authorName,
                fileReference.FileInfo.FileMetadata.ContentType
                                             );

            fileReference._id = newId;
            if (fileReference.FileInfo == null)
            {
                fileReference.FileInfo = new Models.FileInfo();
            }
            fileReference.FileInfo.FileMetadata.ContentType = "audio/mpeg";
            fileReference.FileInfo.FileMetadata.FileType    = FileType.Audio;

            var uploadStream = await gridFsBucket.OpenUploadStreamAsync
                               (
                newId,
                newId.ToString(),
                new GridFSUploadOptions
            {
                Metadata = fileReference.FileInfo.FileMetadata.ToBsonDocument(),
            }
                               );

            await newAudio.CopyToAsync(uploadStream);

            await uploadStream.CloseAsync();

            var deleteOldTask = gridFsBucket.DeleteAsync(oldId);

            return(seconds);
        }
Esempio n. 6
0
        public async Task <SongResponse> Create([FromBody] CreateSongRequest request)
        {
            var artist = await _authenticatedUser.GetArtistAsync();

            var album = await _albumCollection.GetAlbumByIdAsync(request.AlbumId);

            if ((await album.GetArtistAsync()).Id != artist.Id)
            {
                throw new HttpException(HttpStatusCode.Unauthorized);
            }

            var song = await album.CreateSongAsync(request.Name, request.Duration);

            if (song == null)
            {
                throw new HttpException(HttpStatusCode.InternalServerError);
            }

            return(await SongResponse.CreateFromSongAsync(song));
        }
Esempio n. 7
0
 public async Task Create(CreateSongRequest req)
 {
     var song = new Song(req);
     await _songs.InsertOneAsync(song);
 }
Esempio n. 8
0
        public async Task <StatusCodeResult> Create(CreateSongRequest req)
        {
            await _songService.Create(req);

            return(new StatusCodeResult(201));
        }
Esempio n. 9
0
 public int Post(CreateSongRequest song, CancellationToken ct)
 {
     return(_songService.AddSong(song, ct));
 }
        public async Task <dynamic> Post([FromBody] CreateSongRequest requestBody)
        {
            var userId = new ObjectId(this.GetCurrentUserId());

            Task <(FileReference, Func <Task>)> fileReferenceTask = Task.FromResult <(FileReference, Func <Task>)>((null, () => Task.CompletedTask));

            if (requestBody.IdResource != null)
            {
                fileReferenceTask = GeneralUtils.GetFileForReferenceToken
                                    (
                    MongoWrapper,
                    requestBody.IdResource,
                    userId
                                    );
            }

            var userCollection = MongoWrapper.Database.GetCollection <Models.Musician>(nameof(User));

            var userFilterBuilder = new FilterDefinitionBuilder <Models.Musician>();
            var userFilter        = userFilterBuilder.And(
                GeneralUtils.NotDeactivated(userFilterBuilder),
                userFilterBuilder.Eq(u => u._id, userId)
                );

            var userTask = userCollection.FindAsync(userFilter, new FindOptions <Musician>
            {
                AllowPartialResults = false,
                Projection          = new ProjectionDefinitionBuilder <Musician>()
                                      .Include(m => m.FileBytesLimit)
                                      .Include(m => m.FileBytesOccupied)
                                      .Include(m => m.FullName)
                                      .Include("_t")
            });

            var(fileReference, consumeFileAction) = await fileReferenceTask;

            if (fileReference == null)
            {
                return(new ResponseBody
                {
                    Code = ResponseCode.NotFound,
                    Message = "Arquivo não encontrado!",
                    Success = false,
                });
            }

            var user = (await userTask).Single();

            GeneralUtils.CheckSizeForUser(fileReference.FileInfo.Size, user.FileBytesOccupied, user.FileBytesLimit);

            var audioNormalizeTask = NormalizeAudio(fileReference, requestBody, user.FullName);

            await audioNormalizeTask;

            var creationDate = DateTime.UtcNow;
            var song         = new Models.Song
            {
                _id              = ObjectId.GenerateNewId(creationDate),
                Name             = requestBody.Nome,
                RadioAuthorized  = requestBody.AutorizadoRadio,
                Original         = requestBody.Autoral,
                AudioReference   = fileReference,
                DurationSeconds  = (uint)await audioNormalizeTask,
                TimesPlayed      = 0,
                TimesPlayedRadio = 0,
            };

            var userUpdateBuilder = new UpdateDefinitionBuilder <Models.Musician>();
            var userUpdate        = userUpdateBuilder.AddToSet(m => m.Songs, song);

            var updateResult = await userCollection.UpdateOneAsync(userFilter, userUpdate);

            await consumeFileAction();

            return(new ResponseBody
            {
                Code = ResponseCode.GenericSuccess,
                Data = song._id,
                Message = "Música adicionada com sucesso!",
                Success = true
            });
        }