public async Task <IActionResult> UploadFile([FromRoute] Guid id, [FromForm] CreateTrackRequest createTrackRequest)
{
var identity = HttpContext.User.Identity as ClaimsIdentity;
var userIdFromToken = identity.Claims.FirstOrDefault(x => x.Type == "id");
var claimValue = userIdFromToken.Value;
if (claimValue != id.ToString())
{
return(this.StatusCode(403));
}
if (createTrackRequest.Track == null || createTrackRequest.Track.Length == 0)
{
return(Content("file not selected"));
}
var result = await this.trackService.UploadTrack(id, createTrackRequest.Track, createTrackRequest);
if (result.Errors.Any())
{
return(this.BadRequest(result));
}
return(this.Ok(result));
}
public async Task <TrackDto> Create(CreateTrackRequest request)
{
var command = new CreateTrackCommand {
Id = Guid.NewGuid(), Request = request
};
await _commandExecutor.ExecuteAsync(command);
return(await Get(command.Id));
}
public IActionResult CreateTrack([FromBody] CreateTrackRequest request)
{
var createdTrack = _trackService.CreateTrack(
User.GetUserId(),
request.Name,
request.CreatedAt,
_mapper.Map <IEnumerable <CustomizationType> >(request.AllowedCustomizations));
var response = _mapper.Map <TrackModel>(createdTrack);
return(Ok(response));
}
public async Task <CreateTracksResponse> UploadTrack(Guid customerId, IFormFile track, CreateTrackRequest creteTrackRequest)
{
var baseTrackPath = $@"TurnItUp\Tracks";
var trackLocationBase = "Tracks";
var identityUser = await this.userManager.FindByIdAsync(customerId.ToString());
if (identityUser == null)
{
return(new CreateTracksResponse
{
Errors = new List <Infrastructure.CrossCutting.Helpers.Error>
{
new Infrastructure.CrossCutting.Helpers.Error("Invalid track request", "Customer id provided does not belong to any customer")
}
});
}
var customer = this.context.Customers
.Include(x => x.Tracks)
.FirstOrDefault(x => x.IdentityId == identityUser.Id);
if (customer == null)
{
return(new CreateTracksResponse
{
Errors = new List <Infrastructure.CrossCutting.Helpers.Error>
{
new Infrastructure.CrossCutting.Helpers.Error("Invalid track request", "Customer id provided does not belong to any customer")
}
});
}
if (customer.Tracks == null)
{
customer.Tracks = new List <Domain.Model.Tracks.Track>();
}
Directory.CreateDirectory($@"C:\{baseTrackPath}\{customer.IdentityId}");
var path = Path.Combine(
$@"C:\{baseTrackPath}\{customer.IdentityId}\",
track.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
await track.CopyToAsync(stream);
}
TagLib.File fileInfo = TagLib.File.Create(path, TagLib.ReadStyle.Average);
var duration = (int)fileInfo.Properties.Duration.TotalSeconds;
float mb = track.Length / 1024 / 1024;
if (mb > 50)
{
return(new CreateTracksResponse
{
Errors = new List <Infrastructure.CrossCutting.Helpers.Error>
{
new Infrastructure.CrossCutting.Helpers.Error("Invalid track request", "File to upload cannot exceed 50 mb")
}
});
}
var trackToCreate = new Domain.Model.Tracks.Track
{
FileName = track.FileName.Split('.')[0],
Extension = track.FileName.Split('.')[1],
DurationInSeconds = duration,
TrackAudioLocation = $@"{trackLocationBase}/{customer.IdentityId}/{track.FileName}",
ArtistName = creteTrackRequest.ArtistName,
TrackName = creteTrackRequest.TrackName
};
customer.Tracks.Add(trackToCreate);
this.context.Customers.Update(customer);
await this.context.SaveChangesAsync();
return(new CreateTracksResponse
{
TrackId = trackToCreate.Id,
TrackAudioLocation = $@"{trackLocationBase}/{customer.IdentityId}/{track.FileName}",
Errors = new List <Infrastructure.CrossCutting.Helpers.Error>()
});
}
public async Task <ActionResult <Track> > Create([FromForm] CreateTrackRequest request)
{
var file = TagLib.File.Create(new FormFileAbstraction(request.Song));
var entity = new Track
{
Title = request.Title ?? file.Tag.Title,
Performers = request.Performers ?? string.Join(", ", file.Tag.Performers),
Album = request.Album ?? file.Tag.Album,
Year = request.Year ?? (file.Tag.Year == 0 ? null : file.Tag.Year),
Duration = (long)file.Properties.Duration.TotalMilliseconds,
IsPublic = request.IsPublic,
UploaderId = UserId
};
if (request.PlaylistId != null)
{
var playlist =
await _dbContext.Playlist.FirstOrDefaultAsync(
x => x.Id == request.PlaylistId && x.OwnerId == UserId);
if (playlist == null)
{
return(StatusCode(StatusCodes.Status403Forbidden, "No permission on this playlist"));
}
entity.PlaylistTracks = new List <PlaylistTrack>
{
new PlaylistTrack
{
PlaylistId = request.PlaylistId.Value,
TrackId = entity.Id
}
};
}
if (request.IsFavorite)
{
entity.FavoriteTracks = new List <FavoriteTrack>
{
new FavoriteTrack
{
TrackId = entity.Id,
UserId = UserId.Value
}
};
entity.IsFavorite = true;
}
if (request.Cover != null)
{
entity.CoverUrl = await _storageService.UploadFile(
"covers",
request.Cover.FileName,
request.Cover,
false);
}
else if (file.Tag.Pictures != null && file.Tag.Pictures.Any())
{
entity.CoverUrl = await _storageService.UploadFile(
"covers",
file.Tag.Pictures[0].Filename ?? $"{Path.GetFileNameWithoutExtension(request.Song.FileName)}.{file.Tag.Pictures[0].MimeType.Split("/")[1]}",
file.Tag.Pictures[0].Data.Data,
false);
}
//var fileName = $"{entity.Title} - {entity.Performers}{Path.GetExtension(request.File.FileName)}";
entity.Url = await _storageService.UploadFile(
"tracks",
request.Song.FileName,
request.Song,
false);
entity = _dbContext.Track.Add(entity).Entity;
_dbContext.SaveChanges();
return(CreatedAtAction(nameof(Create), entity));
}
