/// <summary>
/// Add a track to the database
/// </summary>
public void Add(TrackDto track)
{
if (track == null)
{
throw new ArgumentNullException("track");
}
// Compute the first letter of the artists name for the artists_by_first_letter table
string artistFirstLetter = track.Artist.Substring(0, 1).ToUpper();
PreparedStatement preparedStatement = _session.Prepare("INSERT INTO artists_by_first_letter (first_letter, artist) VALUES (?, ?)");
BoundStatement boundStatement = preparedStatement.Bind(artistFirstLetter, track.Artist);
_session.Execute(boundStatement);
preparedStatement =
_session.Prepare("INSERT INTO track_by_id (genre, track_id, artist, track, track_length_in_seconds) VALUES (?, ?, ?, ?, ?)");
boundStatement = preparedStatement.Bind(track.Genre, track.TrackId, track.Artist, track.Track, track.LengthInSeconds);
_session.Execute(boundStatement);
preparedStatement =
_session.Prepare("INSERT INTO track_by_genre (genre, track_id, artist, track, track_length_in_seconds) VALUES (?, ?, ?, ?, ?)");
boundStatement = preparedStatement.Bind(track.Genre, track.TrackId, track.Artist, track.Track, track.LengthInSeconds);
_session.Execute(boundStatement);
preparedStatement =
_session.Prepare("INSERT INTO track_by_artist (genre, track_id, artist, track, track_length_in_seconds) VALUES (?, ?, ?, ?, ?)");
boundStatement = preparedStatement.Bind(track.Genre, track.TrackId, track.Artist, track.Track, track.LengthInSeconds);
_session.Execute(boundStatement);
}
public TrackDto AddTrackToProjectById(int projectId, TrackDto track, string userName)
{
var projectTrack = new project_track()
{
projectid = projectId,
trackname = track.TrackName,
isworkingtitle = false,
updatedby = userName,
updatedon = DateTime.Now,
createdby = userName,
createdon = DateTime.Now,
isrc = track.Isrc,
duration = track.Duration,
donotpublish = false,
trackorder = track.TrackOrder,
recordingid = track.RecordingId
};
_projectTrackRepository.Add(projectTrack);
_unitOfWork.Commit();
track.Id = projectTrack.id;
return(track);
}
/// <summary>
/// Maps a Cassandra row to a TrackDto. Could be replaced with something like AutoMapper.
/// </summary>
private static TrackDto MapRowToTrackDto(Row row, bool includeStarred = true)
{
if (row == null)
{
return(null);
}
var dto = new TrackDto
{
TrackId = row.GetValue <Guid>("track_id"),
Artist = row.GetValue <string>("artist"),
Track = row.GetValue <string>("track"),
Genre = row.GetValue <string>("genre"),
MusicFile = row.GetValue <string>("music_file"),
LengthInSeconds = row.GetValue <int>("track_length_in_seconds")
};
if (includeStarred == false)
{
return(dto);
}
// If the field doesn't exist or is null we set it to false (this is WAY more efficient than wrapping a
// GetValue<bool> in a try...catch because we don't incur the Exception overhead)
var starred = row.GetValue <bool?>("starred");
dto.Starred = starred ?? false;
return(dto);
}
public void CreateTrack_UnderNormalConditions_AddsTrackToTrackList()
{
//arrange
var originalCountOfTracks = _trackList.Count;
var trackToCreate = new TrackDto()
{
TrackId = 6,
TrackName = "track 6",
TrackDescription = "track description 6",
IsActive = true
};
var mockRepo = Mock.Create <ITrackRepository>();
Mock.Arrange(() => mockRepo.Create(Arg.IsAny <Track>()))
.DoInstead(() => _trackList.Add(trackToCreate))
.OccursOnce();
_trackService = new TrackService(mockRepo);
//act
_trackService.Create(trackToCreate);
var actualCount = _trackList.Count;
//assert
Mock.Assert(mockRepo);
Assert.That(actualCount, Is.EqualTo(originalCountOfTracks + 1));
}
public void CreateTrack_UnderNormalConditions_ReturnsOkResponse()
{
//arrange
var trackToCreate = new TrackDto()
{
TrackId = 7,
IsActive = true,
TrackDescription = "test description 7",
TrackName = "track name 7"
};
Mock.Arrange(() => _trackService.Create(trackToCreate))
.Returns(trackToCreate)
.OccursOnce();
var trackController = new TrackController(_trackService)
{
Request = new HttpRequestMessage()
{
RequestUri = new Uri("http://localhost/api/track")
}
};
//act
var actual = trackController.Post(trackToCreate) as CreatedNegotiatedContentResult <TrackDto>;
var actualContent = actual.Content;
//assert
Mock.Assert(_trackService);
Assert.That(actual, Is.Not.Null);
Assert.That(actual, Is.TypeOf <CreatedNegotiatedContentResult <TrackDto> >());
Assert.That(actualContent, Is.EqualTo(trackToCreate));
}
public ActionResult StarTrack(StarTrackModel model)
{
TrackDto dbTrack = _tracksDao.GetTrackById(model.TrackId);
_tracksDao.Star(dbTrack);
return(Redirect(model.ReturnUrl));
}
public async Task <TrackDto> CreateAsync(TrackDto item)
{
var result = _context.Tracks.Add(TrackConverter.Convert(item));
await _context.SaveChangesAsync();
return(TrackConverter.Convert(result.Entity));
}
private Dictionary <int, EventDto> PrintEventList(UserDto userDto, TrackDto trackDto)
{
var result = _eventService.GetEvents(userDto.Id, trackDto.Id);
var events = new Dictionary <int, EventDto>();
if (!result.Any())
{
Console.WriteLine("Список событий пока пуст");
}
else
{
Console.WriteLine("{0,-3} {1,-30} {2,-10}", "№", "CreatedAt", "Customizations");
int i = 0;
foreach (var @event in result)
{
i++;
events[i] = @event;
Console.Write("{0,-3} {1,-20}",
i,
@event.CreatedAt.ToString("g", CultureInfo.CreateSpecificCulture("de-DE")));
Console.WriteLine();
}
}
return(events);
}
public ICollection <TrackDto> GetAllTracks()
{
var tracks = _trackRepository.GetAll();
if (!tracks.IsNullOrEmpty())
{
ICollection <TrackDto> tracksDto = new LinkedList <TrackDto>();
TrackDto trackDto = null;
foreach (Track track in tracks)
{
trackDto = new TrackDto(track.Id, track.Title, track.DateReleased);
if (track.ArtistTracks.Count > 0)
{
foreach (ArtistTrack artistTrack in track.ArtistTracks)
{
trackDto.Artists.Add(new ArtistDto(artistTrack.Artist.Id,
artistTrack.Artist.DisplayName,
artistTrack.Artist.Firstname, artistTrack.Artist.Lastname,
new ArtistDetailsDto {
StageName = artistTrack.Artist.ArtistDetails.StageName
},
artistTrack.Artist.ConcurrencyStamp));
}
}
tracksDto.Add(trackDto);
}
return(tracksDto);
}
return(null);
}
public void Execute(TrackDto dto)
{
_validator.ValidateAndThrow(dto);
var tracks = _context.Track.ToList();
dto.Id = 0;
foreach (var t in tracks)
{
if (t.TrackId > dto.Id)
{
dto.Id = t.TrackId;
}
}
dto.Id = dto.Id + 1;
var track = _mapper.Map <Track>(dto);
track.TrackId = dto.Id;
_context.Track.Add(track);
_context.SaveChanges();
}
public IHttpActionResult Put(TrackDto track)
{
using (_trackService)
{
var response = _trackService.Update(track);
return(Ok(response));
}
}
public IHttpActionResult Post(TrackDto track)
{
using (_trackService)
{
var response = _trackService.Create(track);
return(Created(new Uri(Request.RequestUri, $"{response.TrackId}"), response));
}
}
public TrackDto FillAudioFile(HttpPostedFileBase audioFile, TrackDto trackDto)
{
if (audioFile != null)
{
trackDto.AudioFilePath = AudioHelper.SaveAudioForTrackForPolitician(audioFile, trackDto);
}
return(trackDto);
}
public IHttpActionResult AddTrackToProjectById(int projectId, [FromBody] TrackDto track)
{
if (!ModelState.IsValid)
{
return(BadRequest("Model is not valid."));
}
return(Ok(_projectService.AddTrackToProjectById(projectId, track, User.Identity.Name)));
}
public async Task <TrackDto> Update(TrackDto item)
{
Track track = _mapper.Map <TrackDto, Track>(item);
track = await _database.TrackRepository.Update(track);
return(_mapper.Map <Track, TrackDto>(track));
}
public async Task <IActionResult> Index()
{
var cities = await _repo.GetKsacities();
var dto = new TrackDto();
dto.Ksacities = cities;
return(View(dto));
}
public static Track Convert(TrackDto track)
{
return(new Track
{
Id = track.Id,
Title = track.Title,
IdAlbum = track.IdAlbum,
});
}
public static Track Convert(TrackDto track)
{
return(new Track
{
Title = track.Title,
Id = track.Id,
AlbumId = track.AlbumId
});
}
private async Task <Track> GetTrackFromDatabaseOrCreateAndGet(TrackDto track)
{
Track trackFromDb = _database.TrackRepository.GetByName(track.Name);
if (trackFromDb == null)
{
trackFromDb = await _database.TrackRepository.Create(_mapper.Map <TrackDto, Track>(track));
}
return(trackFromDb);
}
private async Task AddTracksToDatabaseIfNeeded(IEnumerable <string> trackNames, string albumId)
{
IEnumerable <string> trackNamesToAdd = GetTrackNamesWhichNotInDatabase(trackNames);
foreach (var trackName in trackNames)
{
TrackDto trackToAdd = GetTrackDto(trackName, albumId);
await _database.TrackRepository.Create(_mapper.Map <TrackDto, Track>(trackToAdd));
}
}
public async Task <IActionResult> Put([FromBody] TrackDto item)
{
try
{
return(Ok(await _repo.UpdateAsync(item)));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public async Task <IActionResult> SetTrackCloudUrl([FromBody] TrackModel trackModel)
{
TrackDto track = await _trackService.Update(_mapper.Map <TrackModel, TrackDto>(trackModel));
if (track == null)
{
return(BadRequest("trackId is incorrect"));
}
return(Ok(_mapper.Map <TrackDto, TrackModel>(track)));
}
public async Task <IActionResult> UploadTrackThroughConsole([FromBody] TrackModel trackModel)
{
TrackDto track = await _trackService.UploadTrackThroughConsole(_mapper.Map <TrackModel, TrackDto>(trackModel));
if (track == null)
{
return(BadRequest("some data is incorrect"));
}
return(Ok(_mapper.Map <TrackDto, TrackModel>(track)));
}
public async Task <TrackDto> UploadTrackThroughConsole(TrackDto track)
{
TrackDto lastFmTrack = await _lastFm.GetFullInfoTrack(track.ArtistName, track.Name);
if (string.IsNullOrEmpty(lastFmTrack.Name))
{
return(null);
}
lastFmTrack.CloudURL = track.CloudURL;
return(await UpdateTrackInDatabaseOrCreateIfNeeded(lastFmTrack));
}
public static Track MapTrackDto(TrackDto trackDto)
{
return(new Track
{
Id = trackDto.Id,
Name = trackDto.Name,
Date = trackDto.Date,
Path = trackDto.AudioFilePath,
Md5Hash = trackDto.Md5Hash
});
}
public ActionResult <TrackDto> Update(TrackDto trackDto, [FromRoute] long albumId)
{
TrackModel trackModel = _mapper.Map <TrackModel>(trackDto);
trackModel.AlbumId = albumId;
_service.UpdateTrack(trackModel);
_service.Save();
return(NoContent()); // 204
}
private void HandleTrackMessage(TrackDto track)
{
CurrentTrack = new Track
{
Artist = track.Artist,
Title = track.Title,
Album = track.Album,
AlbumArtUrl = track.AlbumArt
};
TrackChanged?.Invoke(this, new TrackChangedEventArgs(CurrentTrack));
}
public async Task <bool> UpdateAsync(TrackDto item)
{
if (item == null)
{
return(false);
}
_context.Tracks.Update(TrackConverter.Convert(item));
await _context.SaveChangesAsync();
return(true);
}
public TrackDto Update(TrackDto entity)
{
using (_trackRepository)
{
var entityToUpdate = entity.ConvertToTrackDbModel();
_trackRepository.Update(entityToUpdate);
_trackRepository.SaveChanges();
return(entityToUpdate.ConvertToTrackDto());
}
}
public static TrackDto WriteTrack(RecordingDataSet.Track track)
{
TrackDto trackDto = new TrackDto();
trackDto.id = track.Id;
trackDto.title = track.Title;
trackDto.duration = track.Duration;
trackDto.genreName = track.Genre.Name;
trackDto.artistName = track.Artist.Name;
return trackDto;
}
private void WorkWithEvents(UserDto userDto, TrackDto track)
{
Console.WriteLine("Welcome to Event Menu");
bool isRunning = true;
while (isRunning)
{
Console.WriteLine("---------------------------------------------");
Console.WriteLine("Текущие события:");
var events = PrintEventList(userDto, track);
Console.WriteLine("---------------------------------------------");
Console.WriteLine("Выберите действие из списка:");
Console.WriteLine("1 - посмотреть список событий");
Console.WriteLine("2 - создать событие");
//Console.WriteLine("3 - редактировать событие №");
Console.WriteLine("4 - удалить событие №");
Console.WriteLine("5 - выйти из меню событий");
try
{
var userCase = Convert.ToInt32(Console.ReadLine());
switch (userCase)
{
case 1:
events = PrintEventList(userDto, track);
break;
case 2:
_eventService.CreateEvent(userDto.Id, track.Id, DateTime.Now, new CustomizationsDto());
break;
case 4:
Console.Write("Введите номер событие:");
var num = Convert.ToInt32(Console.ReadLine());
_eventService.DeleteEvent(userDto.Id, events[num].Id);
break;
case 5:
isRunning = false;
break;
default:
Console.WriteLine("Введено несуществующее действие!");
break;
}
}
catch
{
Console.WriteLine("Упс, что-то пошло не так");
}
}
}
public void SetUp()
{
RecordingDataSet recordingDataSet = new RecordingDataSet();
artist = recordingDataSet.Artists.NewArtist();
artist.Id = 1;
artist.Name = "Artist";
recordingDataSet.Artists.AddArtist(artist);
genre = recordingDataSet.Genres.NewGenre();
genre.Id = 1;
genre.Name = "Genre";
recordingDataSet.Genres.AddGenre(genre);
track = recordingDataSet.Tracks.NewTrack();
track.Id = 1;
track.Title = "Track Title";
track.Duration = 100;
track.Genre = genre;
track.Artist = artist;
recordingDataSet.Tracks.AddTrack(track);
trackDto = RecordingAssembler.WriteTrack(track);
}
