podnoms/server/Persistence/PodcastRepository.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using PodNoms.Api.Models;
using PodNoms.Api.Persistence;
using PodNoms.Api.Services.Storage;
using PodNoms.Api.Utils;
using PodNoms.Api.Utils.Extensions;

namespace PodNoms.Api.Persistence
{
    public class PodcastRepository : IPodcastRepository
    {
        private readonly PodnomsDbContext _context;
        public IFileUploader _fileUploader { get; }
        public ImageFileStorageSettings _imageStorageSettings { get; }
        public PodcastRepository(PodnomsDbContext context, IFileUploader fileUploader, IOptions<ImageFileStorageSettings> imageStorageSettings)
        {
            this._imageStorageSettings = imageStorageSettings.Value;
            this._fileUploader = fileUploader;
            this._context = context;
        }
        public async Task<Podcast> GetAsync(int id)
        {
            var ret = await _context.Podcasts
                .Where(p => p.Id == id)
                .Include(p => p.User)
                .FirstOrDefaultAsync();

            return ret;
        }
        public async Task<Podcast> GetAsync(string emailAddress, string slug)
        {
            var ret = await _context.Podcasts
                .Where(p => p.Slug == slug && p.User.EmailAddress == emailAddress)
                .Include(p => p.PodcastEntries)
                .Include(p => p.User)
                .FirstOrDefaultAsync();

            return ret;
        }
        public async Task<IEnumerable<Podcast>> GetAllAsync(string emailAddress)
        {
            var ret = _context.Podcasts
                .Where(u => u.User.EmailAddress == emailAddress)
                .Include(p => p.User)
                .OrderByDescending(p => p.Id);
            return await ret.ToListAsync();
        }
        public async Task<Podcast> AddOrUpdateAsync(Podcast item)
        {
            if (item.Id != 0)
            {
                _context.Entry(item).State = EntityState.Modified;
            }
            else
            {
                var localFile = await HttpUtils.DownloadFile($"http://lorempixel.com/1400/1400/?{System.Guid.NewGuid().ToString()}");
                item.Uid = System.Guid.NewGuid().ToString();
                if (string.IsNullOrEmpty(item.Slug) && !string.IsNullOrEmpty(item.Title))
                {
                    item.Slug = item.Title.Slugify(
                        from p in _context.Podcasts
                        select p.Slug);
                }
                item.ImageUrl = $"{item.Uid}.jpg";
                _context.Podcasts.Add(item);
                var file = await _fileUploader.UploadFile(
                    localFile, _imageStorageSettings.ContainerName, item.ImageUrl, null);
            }

            return item;
        }
        public async Task<int> DeleteAsync(int id)
        {
            var podcast = await _context.Podcasts.SingleAsync(p => p.Id == id);
            if (podcast != null)
            {
                if (podcast.PodcastEntries != null)
                {
                    foreach (var entry in podcast.PodcastEntries)
                    {
                        _context.Remove(entry);
                    }
                }
                _context.Remove<Podcast>(podcast);
            }
            return -1;
        }
    }
}