public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(List <PerformerImputDTO>), new XmlRootAttribute("Performers"));
var performersDTOs = (List <PerformerImputDTO>)serializer.Deserialize(new StringReader(xmlString));
var sb = new StringBuilder();
var performers = new List <Performer>();
var validSongs = context.Songs.Select(s => s.Id).ToList();
foreach (var dto in performersDTOs)
{
var isValid = IsValid(dto);
if (!isValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
var performer = new Performer()
{
FirstName = dto.FirstName,
LastName = dto.LastName,
Age = dto.Age,
NetWorth = dto.NetWorth
};
var isOkToImport = true;
foreach (var song in dto.PerformerSongs)
{
if (!validSongs.Contains(song.Id))
{
sb.AppendLine(ErrorMessage);
isOkToImport = false;
break;
}
var songPerformer = new SongPerformer()
{
SongId = song.Id
};
performer.PerformerSongs.Add(songPerformer);
}
if (isOkToImport)
{
var result = String.Format(SuccessfullyImportedPerformer, performer.FirstName, performer.PerformerSongs.Count());
sb.AppendLine(result);
performers.Add(performer);
}
}
context.Performers.AddRange(performers);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
private static void AddSongPerformers(MusicHubDbContext context, Performer performer, SongPerformerDTO[] performersSongs)
{
var validSongPerformers = new List <SongPerformer>();
foreach (var performerSong in performersSongs)
{
if (IsSongValid(context, performerSong.SongId))
{
SongPerformer songPerformer = new SongPerformer
{
SongId = performerSong.SongId,
Performer = performer
};
validSongPerformers.Add(songPerformer);
}
else
{
context.Performers.Remove(performer);
context.SaveChanges();
return;
}
}
context.SongsPerformers.AddRange(validSongPerformers);
context.SaveChanges();
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(List <ImportSongPerformerDto>),
new XmlRootAttribute("Performers"));
var reader = new StringReader(xmlString);
var songPerformersDto = (List <ImportSongPerformerDto>)serializer.Deserialize(reader);
var performers = new List <Performer>();
var songPerformers = new List <SongPerformer>();
var sb = new StringBuilder();
foreach (var songPerformerDto in songPerformersDto)
{
var performer = Mapper.Map <Performer>(songPerformerDto);
var isAllSongsValid = songPerformerDto.PerformersSongs
.All(x => context.Songs.Any(song => song.Id == x.Id));
if (!IsValid(songPerformerDto) || !isAllSongsValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
foreach (var songDtoId in songPerformerDto.PerformersSongs)
{
var entity = songPerformers
.Count(songPerformer => songPerformer.Performer == performer &&
songPerformer.SongId == songDtoId.Id);
if (context.Songs.Find(songDtoId.Id) != null && entity == 0)
{
var songPerformer = new SongPerformer
{
Performer = performer,
SongId = songDtoId.Id
};
songPerformers.Add(songPerformer);
}
}
performers.Add(performer);
sb.AppendLine(String.Format(SuccessfullyImportedPerformer, performer.FirstName, songPerformerDto.PerformersSongs.Count));
}
context.Performers.AddRange(performers);
context.SongPerformers.AddRange(songPerformers);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var attr = new XmlRootAttribute("Performers");
var serializer = new XmlSerializer(typeof(List <PerformerDto>), attr);
var validSongIds = context
.Songs
.Select(s => s.Id)
.ToList();
StringBuilder sb = new StringBuilder();
var validPerformers = new List <Performer>();
using (StringReader reader = new StringReader(xmlString))
{
var performersDto = (List <PerformerDto>)serializer.Deserialize(reader);
foreach (var performerDto in performersDto)
{
if (!IsValid(performerDto) || performerDto.PerformersSongs.Any(s => !validSongIds.Contains(s.Id)))
{
sb.AppendLine(ErrorMessage);
continue;
}
var performer = new Performer
{
FirstName = performerDto.FirstName,
LastName = performerDto.LastName,
Age = performerDto.Age,
NetWorth = performerDto.NetWorth
};
var performerSongs = new List <SongPerformer>();
foreach (var song in performerDto.PerformersSongs)
{
var performerSongToAdd = new SongPerformer
{
SongId = song.Id,
Performer = performer
};
performerSongs.Add(performerSongToAdd);
}
performer.PerformerSongs = performerSongs;
validPerformers.Add(performer);
sb.AppendLine(string.Format(SuccessfullyImportedPerformer, performer.FirstName, performerSongs.Count));
}
}
context.Performers.AddRange(validPerformers);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var performerDtos = new List <ImportPerformerDto>();
var sb = new StringBuilder();
var serializer = new XmlSerializer(performerDtos.GetType(), new XmlRootAttribute("Performers"));
performerDtos = (List <ImportPerformerDto>)serializer.Deserialize(new StringReader(xmlString));
foreach (var performerDto in performerDtos)
{
var isValidPerformerDto = true;
foreach (var songDto in performerDto.PerformersSongs)
{
if (context.Songs.All(s => s.Id != songDto.Id))
{
isValidPerformerDto = false;
break;
}
}
if (!isValidPerformerDto)
{
sb.AppendLine(ErrorMessage);
continue;
}
var performer = Mapper.Map <Performer>(performerDto);
if (!IsValid(performer))
{
sb.AppendLine(ErrorMessage);
continue;
}
context.Performers.Add(performer);
sb.AppendLine(String.Format(SuccessfullyImportedPerformer, performer.FirstName,
performerDto.PerformersSongs.Count));
foreach (var song in performerDto.PerformersSongs)
{
var sp = new SongPerformer()
{
SongId = song.Id,
Song = context.Songs.Find(song.Id),
Performer = performer,
PerformerId = performer.Id
};
context.SongsPerformers.Add(sp);
}
}
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var importedPerformers = ImportXml <PerformerSongImportDto>(xmlString, "Performers");
var validSongIds = context.Songs.Select(s => s.Id).ToList();
var performersToAdd = new List <Performer>();
StringBuilder sb = new StringBuilder();
var songBondsToInsert = new List <SongPerformer>();
foreach (var per in importedPerformers.ToList())
{
bool isValidObj = IsValid(per);
bool validCollections = per.PerformersSongs.All(p => validSongIds.Contains(p.Id));
if (isValidObj is false || validCollections is false)
{
sb.AppendLine(ErrorMessage);
continue;
}
var performer = new Performer()
{
Age = per.Age,
FirstName = per.FirstName,
LastName = per.LastName,
NetWorth = per.NetWorth,
};
foreach (var s in per.PerformersSongs)
{
var current = new SongPerformer()
{
Performer = performer,
SongId = s.Id
};
songBondsToInsert.Add(current);
performer.PerformerSongs.Add(current);
}
sb.AppendLine(
string.Format(SuccessfullyImportedPerformer,
performer.FirstName,
performer.PerformerSongs.Count));
}
//not sure if i should add the mapping table or this way it is enough?
context.Performers.AddRange(performersToAdd);
context.SongsPerformers.AddRange(songBondsToInsert);
context.SaveChanges();
var x = sb.ToString().TrimEnd();
return(x);
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(ImportPerformerModel[]), new XmlRootAttribute("Performers"));
var performerModels = (ImportPerformerModel[])serializer.Deserialize(new StringReader(xmlString));
var sb = new StringBuilder();
foreach (var performerModel in performerModels)
{
if (!IsValid(performerModel))
{
sb.AppendLine("Invalid data");
continue;
}
var performer = new Performer()
{
FirstName = performerModel.FirstName,
LastName = performerModel.LastName,
Age = performerModel.Age,
NetWorth = performerModel.NetWorth
};
bool isSongValid = true;
foreach (var songModel in performerModel.PerformersSongs)
{
var targetSong = context.Songs.FirstOrDefault(x => x.Id == songModel.Id);
if (targetSong == null)
{
isSongValid = false;
break;
}
var performerSong = new SongPerformer()
{
Performer = performer,
SongId = targetSong.Id
};
performer.PerformerSongs.Add(performerSong);
}
if (!isSongValid)
{
sb.AppendLine("Invalid data");
continue;
}
context.Performers.Add(performer);
sb.AppendLine($"Imported {performer.FirstName} ({performer.PerformerSongs.Count()} songs)");
}
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var root = "Performers";
var data = XmlConverter.Deserializer <ImportSongPerformerDTO>(xmlString, root);
StringBuilder sb = new StringBuilder();
foreach (var item in data)
{
if (!IsValid(item))
{
sb.AppendLine(ErrorMessage);
continue;
}
var performer = new Performer
{
FirstName = item.FirstName,
LastName = item.LastName,
Age = item.Age,
NetWorth = item.NetWorth
};
bool isValidPerformer = true;
foreach (var performerSong in item.PerformersSongs)
{
if (!IsValid(performerSong) || !context.Songs.Any(s => s.Id == performerSong.Id))
{
isValidPerformer = false;
sb.AppendLine(ErrorMessage);
break;
}
var ps = new SongPerformer
{
PerformerId = performer.Id,
SongId = performerSong.Id
};
performer.PerformerSongs.Add(ps);
}
if (!isValidPerformer)
{
continue;
}
context.Performers.Add(performer);
sb.AppendLine(string.Format(SuccessfullyImportedPerformer, performer.FirstName, performer.PerformerSongs.Count));
}
context.SaveChanges();
return(sb.ToString());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var sb = new StringBuilder();
var songPerformersRootName = "Performers";
var songPerformersDtos = XmlConverter.Deserializer <ImportSongsPerformersDTO>(xmlString, songPerformersRootName);
var realPerformers = new List <Performer>();
foreach (var songPerformerDto in songPerformersDtos)
{
var areAllSongsValid = true;
foreach (var songId in songPerformerDto.Songs)
{
if (context.Songs.All(x => x.Id != songId.Id))
{
areAllSongsValid = false;
break;
}
}
if (!IsValid(songPerformerDto) || !areAllSongsValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
var newPerformer = new Performer
{
FirstName = songPerformerDto.FirstName,
LastName = songPerformerDto.LastName,
Age = songPerformerDto.Age,
NetWorth = songPerformerDto.NetWorth
};
foreach (var songId in songPerformerDto.Songs)
{
var existedSong = context.Songs.FirstOrDefault(x => x.Id == songId.Id);
var songPerformer = new SongPerformer
{
Performer = newPerformer,
Song = existedSong
};
newPerformer.PerformerSongs.Add(songPerformer);
}
realPerformers.Add(newPerformer);
sb.AppendLine(string.Format(SuccessfullyImportedPerformer, newPerformer.FirstName, newPerformer.PerformerSongs.Count));
}
context.Performers.AddRange(realPerformers);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public async Task <Unit> Handle(Command request,
CancellationToken cancellationToken)
{
var songSet = new SongSet[]
{
new SongSet {
SongId = request.Id,
SetId = request.SongSet[0].Set.Id,
}
};
var songPerformer = new SongPerformer[]
{
new SongPerformer {
SongId = request.Id,
PerformerId = request.SongPerformer[0].Performer.Id,
}
};
var song = new Song
{
Id = request.Id,
Name = request.Name,
Genre = request.Genre,
Text = request.Text,
SongSet = songSet,
SongPerformer = songPerformer,
};
context.Songs.Add(song);
//var user = await context.Users.SingleOrDefaultAsync(x => x.UserName == userAccessor.GetCurrentUsername());
//var set = await context.Sets.SingleOrDefaultAsync(x => x.Id.Equals("271515c0-45e8-4a74-8fa5-01b4bd85fc3a"));
/*var songSet = new SongSet
* {
* Set = request.SongSet[0].Set,
* };
*
* context.SongSet.Add(songSet);
*/
//sca() returns number of saved changes
var success = await context.SaveChangesAsync() > 0;
if (success)
{
return(Unit.Value);
}
throw new Exception("Problem with saving changes!");
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var songIDs = context.Songs.Select(x => x.Id).ToList();
XmlSerializer serializer = new XmlSerializer(typeof(ImportSongPerformerDTO[]), new XmlRootAttribute("Performers"));
StringReader rdr = new StringReader(xmlString);
ImportSongPerformerDTO[] songsPerformerDTO = (ImportSongPerformerDTO[])serializer.Deserialize(rdr);
List <Performer> performers = new List <Performer>();
List <SongPerformer> songsPerformers = new List <SongPerformer>();
var newSB = new StringBuilder();
foreach (var performer in songsPerformerDTO)
{
if (IsValid(performer) && performer.Songs.Select(x => x.Id).All(x => songIDs.Contains(x)))
{
var newPerformer = new Performer()
{
Age = performer.Age,
FirstName = performer.FirstName,
LastName = performer.LastName,
NetWorth = performer.NetWorth,
};
performers.Add(newPerformer);
foreach (var song in performer.Songs.Select(x => x.Id).Distinct())
{
var songPerformer = new SongPerformer()
{
Performer = newPerformer,
SongId = song
};
songsPerformers.Add(songPerformer);
}
newSB.AppendLine(string.Format(SuccessfullyImportedPerformer, performer.FirstName, performer.Songs.Count()));
}
else
{
newSB.AppendLine(ErrorMessage);
}
}
context.Performers.AddRange(performers);
context.SongsPerformers.AddRange(songsPerformers);
context.SaveChanges();
return(newSB.ToString().Trim());
}
public async Task <int> Add(SongPerformerDto input)
{
var songPerformers = new SongPerformer()
{
SongId = input.SongId,
PerformerId = input.PerformerId,
};
await this.repository.AddAsync(songPerformers);
await this.repository.SaveChangesAsync();
return(songPerformers.Id);
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(ImportPerformerDto[]), new XmlRootAttribute("Performers"));
var songPerformersDtos = (ImportPerformerDto[])serializer.Deserialize(new StringReader(xmlString));
var performers = new List <Performer>();
StringBuilder sb = new StringBuilder();
foreach (var songPerformerDto in songPerformersDtos)
{
var performer = Mapper.Map <Performer>(songPerformerDto);
bool isValidPerformer = IsValid(performer);
var songs = context.Songs.Select(s => s.Id).ToList();
var doesSongsExist = songPerformerDto.PerformersSongs
.Select(x => x.Id)
.All(value => songs.Contains(value));
if (isValidPerformer == false || doesSongsExist == false)
{
sb.AppendLine(ErrorMessage);
continue;
}
foreach (var songDto in songPerformerDto.PerformersSongs)
{
SongPerformer songPerformer = new SongPerformer
{
Performer = performer,
PerformerId = performer.Id,
Song = context.Songs.Find(songDto.Id),
SongId = songDto.Id
};
performer.PerformerSongs.Add(songPerformer);
}
performers.Add(performer);
sb.AppendLine(String.Format(SuccessfullyImportedPerformer
, performer.FirstName
, performer.PerformerSongs.Count));
}
context.Performers.AddRange(performers);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var xmlSerializer = new XmlSerializer(typeof(ImportPerformerDto[]),
new XmlRootAttribute("Performers"));
var performers = (ImportPerformerDto[])xmlSerializer
.Deserialize(new StringReader(xmlString));
StringBuilder sb = new StringBuilder();
foreach (var dto in performers)
{
bool hasInvalidSong = dto.SongIds.Any(s => ValidSongId(context, s.Id) == false);
if (IsValid(dto) && !hasInvalidSong)
{
var performer = new Performer
{
FirstName = dto.FirstName,
LastName = dto.LastName,
Age = dto.Age,
NetWorth = dto.NetWorth
};
context.Performers.Add(performer);
foreach (var id in dto.SongIds)
{
var song = context.Songs
.First(s => s.Id == id.Id);
var performerSong = new SongPerformer
{
PerformerId = performer.Id,
SongId = id.Id
};
context.SongsPerformers.Add(performerSong);
}
sb.AppendLine(string.Format(SuccessfullyImportedPerformer
, dto.FirstName, performer.PerformerSongs.Count));
}
else
{
sb.AppendLine(ErrorMessage);
}
}
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(PerformerDto[]), new XmlRootAttribute("Performers"));
var performersDto = (PerformerDto[])serializer.Deserialize(new StringReader(xmlString));
var sb = new StringBuilder();
var performers = new List <Performer>();
foreach (var performerDto in performersDto)
{
var songs = context.Songs.Select(s => s.Id).ToList();
var isValidSong = performerDto.PerformersSongs.Select(s => s.Id).All(s => songs.Contains(s));
if (!IsValid(performerDto) || !isValidSong)
{
sb.AppendLine(ErrorMessage);
continue;
}
var performer = new Performer
{
FirstName = performerDto.FirstName,
LastName = performerDto.LastName,
Age = performerDto.Age,
NetWorth = performerDto.NetWorth,
PerformerSongs = new List <SongPerformer>()
};
foreach (var songDto in performerDto.PerformersSongs)
{
var song = new SongPerformer
{
SongId = songDto.Id
};
performer.PerformerSongs.Add(song);
}
performers.Add(performer);
sb.AppendLine(string.Format(SuccessfullyImportedPerformer, performer.FirstName, performer.PerformerSongs.Count));
}
context.AddRange(performers);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
XmlSerializer ser = new XmlSerializer(typeof(PerformerImportDto[]), new XmlRootAttribute("Performers"));
var performersDto = (PerformerImportDto[])ser.Deserialize(new StringReader(xmlString));
List <Performer> performers = new List <Performer>();
StringBuilder sb = new StringBuilder();
foreach (var performerDto in performersDto)
{
if (!IsValid(performerDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
List <SongPerformer> validSongsPerformers = new List <SongPerformer>();
bool areValidSongs = true;
foreach (var songDto in performerDto.PerformersSongs)
{
if (!context.Songs.Any(s => s.Id == songDto.Id))
{
sb.AppendLine(ErrorMessage);
areValidSongs = false;
break;
}
}
if (!areValidSongs)
{
continue;
}
else
{
var performer = new Performer()
{
FirstName = performerDto.FirstName,
LastName = performerDto.LastName,
Age = performerDto.Age,
NetWorth = performerDto.NetWorth
};
foreach (var songDto in performerDto.PerformersSongs.Distinct())
{
var song = context.Songs.FirstOrDefault(s => s.Id == songDto.Id);
var songPerformer = new SongPerformer()
{
Song = song,
Performer = performer
};
validSongsPerformers.Add(songPerformer);
}
performer.PerformerSongs = validSongsPerformers;
context.SongsPerformers.AddRange(validSongsPerformers);
context.Performers.Add(performer);
sb.AppendLine(string.Format(SuccessfullyImportedPerformer, performer.FirstName,
performer.PerformerSongs.Count));
context.SaveChanges();
}
}
return(sb.ToString().TrimEnd());
}
public async Task <Unit> Handle(Command request,
CancellationToken cancellationToken)
{
var song = await context.Songs.FindAsync(request.Id);
var songArray = song.SongPerformer.ToArray();
var songSetArray = song.SongSet.ToArray();
if (song == null)
{
throw new RestException(HttpStatusCode.NotFound, new { Song = "Not found!" });
}
//optional edits
song.Name = request.Name ?? song.Name;
song.Genre = request.Genre;
song.Text = request.Text ?? song.Text;
if (songArray[0].PerformerId != request.SongPerformer[0].Performer.Id)
{
var removeObject = song.SongPerformer.ToArray().ElementAt(0);
song.SongPerformer.Remove(removeObject);
var songPerformer = new SongPerformer
{
SongId = song.Id,
PerformerId = request.SongPerformer[0].Performer.Id,
};
song.SongPerformer.Add(songPerformer);
}
if (songSetArray[0].SetId != request.SongSet[0].Set.Id)
{
var removeObject = song.SongSet.ToArray().ElementAt(0);
song.SongSet.Remove(removeObject);
var songSet = new SongSet
{
SongId = song.Id,
SetId = request.SongSet[0].Set.Id,
};
song.SongSet.Add(songSet);
}
//song.SongPerformer = request.SongPerformer ?? song.SongPerformer;
//song.SongSet = request.SongSet ?? song.SongSet;
//sca() returns number of saved changes
var success = await context.SaveChangesAsync() > 0;
if (success)
{
return(Unit.Value);
}
throw new Exception("Problem with saving changes!");
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
StringBuilder stBuilder = new StringBuilder();
var xmlSeserializer = new XmlSerializer(typeof(ImportPerformerDto[]),
new XmlRootAttribute("Performers"));
var performersDto = (ImportPerformerDto[])xmlSeserializer.Deserialize(new StringReader(xmlString));
var performerList = new List <Performer>();
foreach (var performerDto in performersDto)
{
if (!IsValid(performerDto))
{
stBuilder.AppendLine(ErrorMessage);
continue;
}
bool havesongs = true;
var songs = new List <Song>();
foreach (var songDto in performerDto.MappingTable)
{
Song song = context.Songs.Where(s => s.Id == songDto.DtoId).FirstOrDefault();
if (song == null)
{
songs.Clear();
havesongs = false;
break;
}
else
{
songs.Add(song);
}
}
if (!havesongs)
{
stBuilder.AppendLine(ErrorMessage);
continue;
}
var performer = new Performer
{
FirstName = performerDto.FirstName,
LastName = performerDto.LastName,
Age = performerDto.Age,
NetWorth = performerDto.NetWorth
};
context.Performers.Add(performer);
foreach (var song in songs)
{
var songPerformer = new SongPerformer
{
Song = song,
Performer = performer
};
context.SongsPerformers.Add(songPerformer);
}
// Imported { performer first name} ({ songs count}songs)
string message = String.Format(SuccessfullyImportedPerformer, performer.FirstName, songs.Count);
stBuilder.AppendLine(message);
}
string result = stBuilder.ToString().TrimEnd();
context.SaveChanges();
return(result);
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var sb = new StringBuilder();
var listOfPerformers = new List <Performer>();
var listOfSongsPerformers = new List <SongPerformer>();
var xmlSerializer = new XmlSerializer(typeof(XmlImportSongsPerformersDto[]), new XmlRootAttribute("Performers"));
using (var stringReader = new StringReader(xmlString))
{
var prodDtos = (XmlImportSongsPerformersDto[])xmlSerializer.Deserialize(stringReader);
foreach (var perfDto in prodDtos)
{
if (!IsValid(perfDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
var performer = new Performer
{
FirstName = perfDto.FirstName,
LastName = perfDto.LastName,
Age = perfDto.Age,
NetWorth = perfDto.NetWorth
};
var areAllSongsValid = true;
var tempListOfSongPerformers = new List <SongPerformer>();
//Check if all songs pass the validation and only then add them to the performer
foreach (var songDto in perfDto.PerformersSongs.Distinct())
{
if (!IsValid(songDto) || !context.Songs.Any(x => x.Id == songDto.Id))
{
areAllSongsValid = false;
sb.AppendLine(ErrorMessage);
break;
}
var songPerformer = new SongPerformer
{
Performer = performer,
SongId = songDto.Id
};
tempListOfSongPerformers.Add(songPerformer);
}
if (areAllSongsValid)
{
listOfPerformers.Add(performer);
listOfSongsPerformers.AddRange(tempListOfSongPerformers);
sb.AppendLine(string.Format(SuccessfullyImportedPerformer, performer.FirstName, tempListOfSongPerformers.Count));
tempListOfSongPerformers.Clear();
}
}
context.Performers.AddRange(listOfPerformers);
context.SongsPerformers.AddRange(listOfSongsPerformers);
context.SaveChanges();
return(sb.ToString().Trim());
}
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
XmlSerializer serializer = new XmlSerializer(
typeof(ImportPerformerDto[]),
new XmlRootAttribute("Performers"));
var performersDto = (ImportPerformerDto[])serializer.Deserialize(new StringReader(xmlString));
var songsIds = context
.Songs
.Select(s => s.Id)
.ToList();
List <Performer> performers = new List <Performer>();
var sb = new StringBuilder();
List <SongPerformer> songPerformers = new List <SongPerformer>();
foreach (var dto in performersDto)
{
if (!IsValid(dto))
{
sb.AppendLine(ErrorMessage);
continue;
}
var performer = new Performer()
{
FirstName = dto.FirstName,
LastName = dto.LastName,
Age = dto.Age,
NetWorth = dto.NetWorth,
};
List <Song> validSongs = new List <Song>();
int validSongsCount = dto.Songs.Length;
foreach (var song in dto.Songs)
{
if (!songsIds.Contains(song.Id))
{
continue;
}
var currentSong = context
.Songs
.Where(s => s.Id == song.Id)
.First();
validSongs.Add(currentSong);
}
if (validSongs.Count == validSongsCount)
{
performers.Add(performer);
foreach (var song in validSongs)
{
var songPerformer = new SongPerformer()
{
Performer = performer,
SongId = song.Id,
};
songPerformers.Add(songPerformer);
}
sb.AppendLine($"Imported {performer.FirstName} ({validSongs.Count} songs)");
}
else
{
sb.AppendLine(ErrorMessage);
}
}
context
.Performers
.AddRange(performers);
context
.SongsPerformers
.AddRange(songPerformers);
context
.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(ImportPerformerDto[]),
new XmlRootAttribute("Performers"));
var objectsDto = (ImportPerformerDto[])serializer.Deserialize(new StringReader(xmlString));
StringBuilder sb = new StringBuilder();
foreach (var dto in objectsDto)
{
if (!IsValid(dto))
{
sb.AppendLine(ErrorMessage);
continue;
}
Performer performer = new Performer
{
FirstName = dto.FirstName,
LastName = dto.LastName,
Age = dto.Age,
NetWorth = dto.NetWorth
};
List <SongPerformer> songsByPerformer = new List <SongPerformer>();
bool shouldAddPerformer = true;
foreach (var currentSong in dto.PerformersSongs)
{
bool isSongValid = context.Songs.Any(x => x.Id == currentSong.Id);
if (!isSongValid)
{
sb.AppendLine(ErrorMessage);
shouldAddPerformer = false;
break;
}
SongPerformer songPerformer = new SongPerformer
{
SongId = currentSong.Id,
PerformerId = performer.Id
};
songsByPerformer.Add(songPerformer);
context.SongsPerformers.Add(songPerformer);
}
if (shouldAddPerformer)
{
performer.PerformerSongs = songsByPerformer;
context.Performers.Add(performer);
context.SaveChanges();
sb.AppendLine(String.Format(SuccessfullyImportedPerformer,
performer.FirstName,
performer.PerformerSongs.Count));
}
}
return(sb.ToString().TrimEnd());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var xmlSerializer = new XmlSerializer(typeof(List <SongPerformerDto>),
new XmlRootAttribute("Performers"));
var dtos = new List <SongPerformerDto>();
using (var reader = new StringReader(xmlString))
{
dtos = (List <SongPerformerDto>)xmlSerializer.Deserialize(reader);
}
var performers = new List <Performer>();
var sb = new StringBuilder();
foreach (var dto in dtos)
{
var performerSongs = new List <SongPerformer>();
if (IsValid(dto))
{
var performer = new Performer
{
FirstName = dto.FirstName,
LastName = dto.LastName,
Age = dto.Age,
NetWorth = dto.NetWorth,
};
bool haveError = false;
foreach (var song in dto.PerformerSongs)
{
var currentSong = context.Songs.FirstOrDefault(s => s.Id == song.SongId);
if (currentSong == null)
{
haveError = true;
continue;
}
var songPerformer = new SongPerformer
{
Performer = performer,
Song = currentSong
};
performerSongs.Add(songPerformer);
}
if (haveError)
{
sb.AppendLine(ErrorMessage);
continue;
}
performer.PerformerSongs = performerSongs;
performers.Add(performer);
sb.AppendLine($"Imported {performer.FirstName} ({performer.PerformerSongs.Count} songs)");
}
else
{
sb.AppendLine(ErrorMessage);
continue;
}
}
context.Performers.AddRange(performers);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(ImportSongPerformerDto[]), new XmlRootAttribute("Performers"));
var sb = new StringBuilder();
var performerDtos = (ImportSongPerformerDto[])serializer.Deserialize(new StringReader(xmlString));
var songs = new List <Song>();
var ps = new List <SongPerformer>();
foreach (var dto in performerDtos)
{
if (IsValid(dto))
{
var isInvalid = false;
var songIds = new List <int>();
var performer = new Performer
{
FirstName = dto.FirstName,
LastName = dto.LastName,
Age = dto.Age,
NetWorth = dto.NetWorth
};
foreach (var songDto in dto.PerformersSongs)
{
if (context.Songs.Any(s => s.Id == songDto.Id))
{
songIds.Add(songDto.Id);
}
else
{
sb.AppendLine(ErrorMessage);
isInvalid = true;
break;
}
}
if (!isInvalid)
{
context.Performers.Add(performer);
context.SaveChanges();
foreach (var songId in songIds)
{
var sp = new SongPerformer
{
SongId = songId,
PerformerId = performer.Id
};
ps.Add(sp);
}
sb.AppendLine(string.Format(SuccessfullyImportedPerformer, performer.FirstName, songIds.Count));
}
}
else
{
sb.AppendLine(ErrorMessage);
}
}
context.SongsPerformers.AddRange(ps);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var xmlSerializer = new XmlSerializer(typeof(ImportPerformerDto[]),
new XmlRootAttribute("Performers"));
var performerDtos = (ImportPerformerDto[])(xmlSerializer.Deserialize(new StringReader(xmlString)));
var performers = new List <Performer>();
StringBuilder sb = new StringBuilder();
foreach (var performerDto in performerDtos)
{
var isValidPerformer = IsValid(performerDto);
if (!isValidPerformer)
{
sb.AppendLine(ErrorMessage);
continue;
}
var idExists = true;
foreach (var songDto in performerDto.PerformerSongs)
{
idExists = context.Songs.Any(s => s.Id == songDto.SongId);
if (!idExists)
{
sb.AppendLine(ErrorMessage);
break;
}
}
if (idExists)
{
var performer = new Performer
{
FirstName = performerDto.FirstName,
LastName = performerDto.LastName,
Age = performerDto.Age,
NetWorth = performerDto.NetWorth
};
foreach (var songDto in performerDto.PerformerSongs)
{
var song = context.Songs.FirstOrDefault(s => s.Id == songDto.SongId);
var songPerformer = new SongPerformer
{
PerformerId = performer.Id,
Performer = performer,
SongId = song.Id,
Song = song
};
performer.PerformerSongs.Add(songPerformer);
}
performers.Add(performer);
sb.AppendLine(string.Format(
SuccessfullyImportedPerformer,
performer.FirstName,
performer.PerformerSongs.Count));
}
}
context.Performers.AddRange(performers);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(ImportSongPerformer[]),
new XmlRootAttribute("Performers"));
ImportSongPerformer[] importSongPerformers;
var sb = new StringBuilder();
var performers = new List <Performer>();
using (var reader = new StringReader(xmlString))
{
importSongPerformers = (ImportSongPerformer[])serializer.Deserialize(reader);
}
foreach (var dto in importSongPerformers)
{
if (!IsValid(dto))
{
sb.AppendLine(ErrorMessage);
continue;
}
var performer = new Performer
{
FirstName = dto.FirstName,
LastName = dto.LastName,
Age = dto.Age,
NetWorth = dto.NetWorth
};
bool isValidSong = true;
foreach (var songDto in dto.PerformerSongs)
{
var song = context.Songs.FirstOrDefault(x => x.Id == songDto.Id);
if (song == null)
{
sb.AppendLine(ErrorMessage);
isValidSong = false;
break;
}
var songPerformer = new SongPerformer
{
SongId = song.Id
};
performer.PerformerSongs.Add(songPerformer);
}
if (isValidSong)
{
sb.AppendLine(string.Format(SuccessfullyImportedPerformer, performer.FirstName, performer.PerformerSongs.Count));
performers.Add(performer);
continue;
}
}
context.Performers.AddRange(performers);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var xmlSerializer = new XmlSerializer(typeof(ImportPerformerDto[]), new XmlRootAttribute("Performers"));
var sb = new StringBuilder();
using (var reader = new StringReader(xmlString))
{
var performersDto = (ImportPerformerDto[])xmlSerializer.Deserialize(reader);
var performers = new List <Performer>();
foreach (var performerDto in performersDto)
{
if (!IsValid(performerDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
var currentPerformer = new Performer()
{
FirstName = performerDto.FirstName,
LastName = performerDto.LastName,
Age = performerDto.Age,
NetWorth = performerDto.NetWorth
};
bool isSongIdCorrect = true;
foreach (var song in performerDto.PerformersSongs)
{
if (!IsValid(song))
{
sb.AppendLine(ErrorMessage);
isSongIdCorrect = false;
break;
}
var findSongId = context
.Songs
.FirstOrDefault(s => s.Id == song.Id);
if (findSongId == null)
{
sb.AppendLine(ErrorMessage);
isSongIdCorrect = false;
break;
}
SongPerformer songPerformer = new SongPerformer()
{
Song = findSongId,
Performer = currentPerformer
};
currentPerformer.PerformerSongs.Add(songPerformer);
}
if (isSongIdCorrect)
{
performers.Add(currentPerformer);
sb.AppendLine(String.Format(SuccessfullyImportedPerformer, currentPerformer.FirstName, currentPerformer.PerformerSongs.Count));
}
}
context.Performers.AddRange(performers);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
}
public static string ImportSongPerformers(MusicHubDbContext context, string xmlString)
{
var ser = new XmlSerializer(typeof(List <XmlImportPerformer>), new XmlRootAttribute("Performers"));
var res = new StringBuilder();
var performers = new List <Performer>();
var validPerfsDto = new List <XmlImportPerformer>();
var performersDto = (List <XmlImportPerformer>)ser.Deserialize(new StringReader(xmlString));
foreach (var perfDto in performersDto)
{
var invalidId = false;
foreach (var songId in perfDto.SongIds)
{
if (!context.Songs.Any(s => s.Id == songId.Id))
{
invalidId = true;
}
}
if (invalidId || !IsValid(perfDto))
{
res.AppendLine(ErrorMessage);
continue;
}
var performer = Mapper.Map <Performer>(perfDto);
performers.Add(performer);
validPerfsDto.Add(perfDto);
res.AppendLine(string.Format(SuccessfullyImportedPerformer, performer.FirstName, perfDto.SongIds.Count));
}
context.Performers.AddRange(performers);
var songsPerfs = new List <SongPerformer>();
for (int i = 0; i < performers.Count; i++)
{
var perfId = performers[i].Id;
var perfDto = validPerfsDto[i];
foreach (var songId in perfDto.SongIds)
{
var song = new SongPerformer
{
SongId = songId.Id,
PerformerId = perfId
};
songsPerfs.Add(song);
}
}
context.SongsPerformers.AddRange(songsPerfs);
context.SaveChanges();
return(res.ToString().Trim());
}
