/// <summary>
/// Inserts a song.
/// </summary>
/// <param name="song">The song.</param>
/// <returns></returns>
public async Task <ISong> InsertAsync(ISong song)
{
await SongHelper.CreatePdfAsync(song, Path.GetRandomFileName(), true);
SongEntity songEntity = Mapper.Map <SongEntity>(song);
using (IUnitOfWork unitOfWork = Repository.CreateUnitOfWork())
{
foreach (int liturgy in song.LiturgyCategories)
{
SongLiturgyEntity songLiturgy = new SongLiturgyEntity();
songLiturgy.SongId = songEntity.Id;
songLiturgy.LiturgyId = liturgy;
await unitOfWork.InsertAsync <SongLiturgyEntity>(songLiturgy);
}
foreach (int theme in song.ThemeCategories)
{
SongThemeEntity songTheme = new SongThemeEntity();
songTheme.SongId = songEntity.Id;
songTheme.ThemeId = theme;
await unitOfWork.InsertAsync <SongThemeEntity>(songTheme);
}
if (song.Arranger != null)
{
songEntity.Arranger = null;
songEntity.ArrangerId = song.Arranger.Id;
}
if (song.Composer != null)
{
songEntity.Composer = null;
songEntity.ComposerId = song.Composer.Id;
}
songEntity = await unitOfWork.InsertAsync <SongEntity>(songEntity);
await unitOfWork.CommitAsync();
}
return(Mapper.Map <ISong>(songEntity));
}
/// <summary>
/// Updates a song.
/// </summary>
/// <param name="song">The song.</param>
/// <returns></returns>
public async Task <ISong> UpdateAsync(ISong song)
{
string[] options = new String[4] {
"Stanzas", "InstrumentalParts", "LiturgyCategories", "ThemeCategories"
};
SongEntity songEntity = Mapper.Map <SongEntity>(song);
SongEntity songDb = await Repository.GetById(song.Id, options);
await SongHelper.UpdatePdfAsync(song, Path.GetRandomFileName(), SongHelper.SongFileName(Mapper.Map <ISong>(songDb)), true);
using (IUnitOfWork unitOfWork = Repository.CreateUnitOfWork())
{
// updating stanzas
for (int i = songDb.Stanzas.Count - 1; i >= 0; i--)
{
StanzaEntity stanzaDb = songDb.Stanzas.ElementAt(i);
StanzaEntity foundStanza = songEntity.Stanzas.SingleOrDefault(s => s.Id.Equals(stanzaDb.Id));
if (object.Equals(foundStanza, default(StanzaEntity)))
{
await unitOfWork.DeleteAsync <StanzaEntity>(stanzaDb);
}
}
foreach (StanzaEntity stanza in songEntity.Stanzas)
{
if (stanza.Id == 0)
{
stanza.SongId = song.Id;
await unitOfWork.InsertAsync <StanzaEntity>(stanza);
}
else
{
StanzaEntity stanzaDb = songDb.Stanzas.SingleOrDefault(s => s.Id.Equals(stanza.Id));
stanzaDb.Number = stanza.Number;
stanzaDb.Text = stanza.Text;
await unitOfWork.UpdateAsync <StanzaEntity>(stanzaDb);
}
}
// updating instrumental parts
for (int i = songDb.InstrumentalParts.Count - 1; i >= 0; i--)
{
InstrumentalPartEntity partDb = songDb.InstrumentalParts.ElementAt(i);
InstrumentalPartEntity foundPart = songEntity.InstrumentalParts.SingleOrDefault(p => p.Id.Equals(partDb.Id));
if (object.Equals(foundPart, default(InstrumentalPartEntity)))
{
await unitOfWork.DeleteAsync <InstrumentalPartEntity>(partDb);
}
}
foreach (InstrumentalPartEntity part in songEntity.InstrumentalParts)
{
if (part.Id == 0)
{
part.SongId = song.Id;
await unitOfWork.InsertAsync <InstrumentalPartEntity>(part);
}
else
{
InstrumentalPartEntity partDb = songDb.InstrumentalParts.SingleOrDefault(p => p.Id.Equals(part.Id));
partDb.Code = part.Code;
partDb.Position = part.Position;
partDb.Template = part.Template;
partDb.Type = part.Type;
await unitOfWork.UpdateAsync <InstrumentalPartEntity>(partDb);
}
}
// updating liturgy categories
for (int i = songDb.LiturgyCategories.Count - 1; i >= 0; i--)
{
SongLiturgyEntity songLiturgyDb = songDb.LiturgyCategories.ElementAt(i);
int foundLiturgy = song.LiturgyCategories.SingleOrDefault(l => l.Equals(songLiturgyDb.LiturgyId));
if (object.Equals(foundLiturgy, default(int)))
{
await unitOfWork.DeleteAsync <SongLiturgyEntity>(songLiturgyDb);
}
}
foreach (int liturgy in song.LiturgyCategories)
{
SongLiturgyEntity songLiturgyDb = songDb.LiturgyCategories.SingleOrDefault(l => l.LiturgyId.Equals(liturgy));
if (songLiturgyDb == null)
{
SongLiturgyEntity songLiturgy = new SongLiturgyEntity
{
LiturgyId = liturgy,
SongId = song.Id
};
await unitOfWork.InsertAsync <SongLiturgyEntity>(songLiturgy);
}
}
// updating theme categories
for (int i = songDb.ThemeCategories.Count - 1; i >= 0; i--)
{
SongThemeEntity songThemeDb = songDb.ThemeCategories.ElementAt(i);
int foundTheme = song.LiturgyCategories.SingleOrDefault(t => t.Equals(songThemeDb.ThemeId));
if (object.Equals(foundTheme, default(int)))
{
await unitOfWork.DeleteAsync <SongThemeEntity>(songThemeDb);
}
}
foreach (int theme in song.ThemeCategories)
{
SongThemeEntity songThemeDb = songDb.ThemeCategories.SingleOrDefault(l => l.ThemeId.Equals(theme));
if (songThemeDb == null)
{
SongThemeEntity songTheme = new SongThemeEntity
{
ThemeId = theme,
SongId = song.Id
};
await unitOfWork.InsertAsync <SongThemeEntity>(songTheme);
}
}
songDb.ArrangerId = null;
songDb.Code = songEntity.Code;
songDb.ComposerId = null;
songDb.OtherInformations = songEntity.OtherInformations;
songDb.Source = songEntity.Source;
songDb.Template = songEntity.Template;
songDb.Title = songEntity.Title;
songDb.Type = songEntity.Type;
if (songEntity.Arranger != null)
{
songDb.ArrangerId = songEntity.Arranger.Id;
}
if (songEntity.Composer != null)
{
songDb.ComposerId = songEntity.Composer.Id;
}
songDb = await unitOfWork.UpdateAsync(songDb);
await unitOfWork.CommitAsync();
}
return(Mapper.Map <ISong>(songDb));
}
