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));
}
public Song(CreateSongRequest req)
{
Name = req.Name;
ArtistId = req.ArtistId;
Audio = req.Audio;
CategoriesId = req.CategoriesId;
}
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());
}
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);
}
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));
}
public async Task Create(CreateSongRequest req)
{
var song = new Song(req);
await _songs.InsertOneAsync(song);
}
public async Task <StatusCodeResult> Create(CreateSongRequest req)
{
await _songService.Create(req);
return(new StatusCodeResult(201));
}
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
});
}