public async Task <BaseResponseMessage> UpdateSeries(SeriesModel series)
{
var newSeries = _mapper.Map <Series>(series);
var response = new BaseResponseMessage();
var seriesToUpdate = await _seriesRepository.GetSeries(newSeries.Id);
if (seriesToUpdate == null)
{
response.RawData = $"Series with {newSeries.Id} wasn't found.";
return(response);
}
if (seriesToUpdate.Equals(newSeries))
{
response.RawData = $"Series {newSeries.Name} already existing with similar data.";
return(response);
}
await _seriesRepository.UpdateSerires(seriesToUpdate);
response.Id = newSeries.Id;
return(response);
}
static void Main(string[] args)
{
IContainerRepositoriesFactory containerRepositoriesFactory = new ContainerRepositoriesFactory();
IContainerRepositories containerRepositories = new ContainerRepositories();
ISeriesRepository seriesRepository = containerRepositories.SeriesRepository;
seriesRepository.GetSeries()
.ToList()
.ForEach(s => { Console.WriteLine(s.Title); });
Console.ReadKey();
}
public async Task <ActionResult> ChangeSeriesOrder(ChangeSeriesOrderIn model)
{
var email = GetEmail();
var exerciseId = seriesRepository.GetSeries(model.SeriesId, email).ExerciseId;
var series = await seriesRepository.GetSeriesForExerciseAsync(exerciseId, email);
var changedItem =
series.Single(s => s.SeriesId == model.SeriesId);
if (changedItem.Order == model.Order)
{
return(Ok());
}
if (model.Order > series.Max(m => m.Order))
{
model.Order = series.Max(m => m.Order);
}
var seriesInNewOrder = new List <Series>();
if (changedItem.Order < model.Order)
{
seriesInNewOrder = series.Where(w => w.Order <= model.Order && w.SeriesId != changedItem.SeriesId).ToList();
foreach (var exercise in seriesInNewOrder)
{
exercise.Order--;
}
changedItem.Order = model.Order;
seriesInNewOrder.Add(changedItem);
}
if (changedItem.Order > model.Order)
{
{
seriesInNewOrder = series.Where(w =>
w.Order >= model.Order && w.SeriesId != changedItem.SeriesId).ToList();
foreach (var exercise in seriesInNewOrder)
{
exercise.Order++;
}
changedItem.Order = model.Order;
seriesInNewOrder.Add(changedItem);
}
}
_context.UpdateRange(seriesInNewOrder);
await _context.SaveChangesAsync();
return(Ok());
}
public override async Task <Page <SeriesModel> > ExecuteAsync(GetSeriesQuery query, CancellationToken cancellationToken = new CancellationToken())
{
var series = (string.IsNullOrWhiteSpace(query.Query))
? await _seriesRepository.GetSeries(query.LibraryId, query.PageNumber, query.PageSize, cancellationToken)
: await _seriesRepository.FindSeries(query.LibraryId, query.Query, query.PageNumber, query.PageSize, cancellationToken);
foreach (var author in series.Data)
{
if (author != null && author.ImageId.HasValue)
{
author.ImageUrl = await ImageHelper.TryConvertToPublicFile(author.ImageId.Value, _fileRepository, cancellationToken);
}
}
return(series);
}
public Series GetSeries(int id)
{
return(_repository.GetSeries(id));
}
public async Task <SeriesProgress> StartProgress(User viewer, Guid seriesId)
{
var series = await seriesRepository.GetSeries(seriesId);
return(await progressRepository.AddSeriesProgress(viewer, series));
}
public async Task <IEnumerable <Series> > Get()
{
return(await seriesRepository.GetSeries());
}
public async Task <SeriesDto> GetSeries(string title)
{
var internalSeries = await _seriesRepository.GetSeries(title);
return(_seriesMapper.Map(internalSeries));
}