Huge API rewrite

YTManager/Controllers/Channels.cs

@@ -20,7 +20,7 @@ namespace YTManager.Controllers {
                 Title = c.Title;
                 Description = c.Description;
                 ID = c.YoutubeID;
-                Video_IDs = c.Videos?.Select(v => v.YoutubeID).ToList();
+                Video_IDs = c.Videos.Select(v => v.YoutubeID).ToList();
             }
         }
 
@@ -38,6 +38,7 @@ namespace YTManager.Controllers {
         public async Task<IActionResult> Get() {
             // Get all the relevant channels.
             var chanels = await db.Channels
+                .Include(c => c.Videos)
                 .OrderByDescending(i => i.AddedtoDB)
                 .Take(max_per_query)
                 .ToListAsync();

YTManager/Controllers/Raw/Private_Channel.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using YTManager;
+using YTManager.Models;
+
+namespace YTManager.Controllers.Private
+{
+    [Produces("application/json")]
+    [Route("api_raw/Channels")]
+    public class Private_Channel : Controller
+    {
+        private readonly MediaDB db;
+
+        public Private_Channel(MediaDB context)
+        {
+            db = context;
+        }
+
+        [HttpGet]
+        public IEnumerable<Channel> GetChannels()
+        {
+            return db.Channels;
+        }
+
+        [HttpGet("{id}")]
+        public async Task<IActionResult> GetChannel([FromRoute] long id)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            var channel = await db
+                .Channels
+                .Include(c => c.Videos)
+                .SingleOrDefaultAsync(m => m.PrimaryKey == id);
+
+            if (channel == null)
+            {
+                return NotFound();
+            }
+
+            return Ok(channel);
+        }
+
+        [HttpPut("{id}")]
+        public async Task<IActionResult> PutChannel([FromRoute] long id, [FromBody] Channel channel)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            if (id != channel.PrimaryKey)
+            {
+                return BadRequest();
+            }
+
+            db.Entry(channel).State = EntityState.Modified;
+
+            try
+            {
+                await db.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!ChannelExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return NoContent();
+        }
+
+        [HttpPost("{channelid}")]
+        public async Task<IActionResult> PostChannel([FromRoute] string channelid) {
+            // Only add it to the databse if it's not in there already.
+            if (db.Channels.Any(c => c.YoutubeID == channelid))
+                return BadRequest();
+
+            // Get the channel contents from youtube.
+            var channel = await Tasks.FetchVideos.Get_YTChannel(channelid);
+
+            // Add it to the databse.
+            await db.Channels.AddAsync(channel);
+            await db.SaveChangesAsync();
+
+            // Say all went ok.
+            return Ok(channel);
+        }
+
+        [HttpPost]
+        public async Task<IActionResult> PostChannel([FromBody] Channel channel)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            db.Channels.Add(channel);
+            await db.SaveChangesAsync();
+
+            return CreatedAtAction("GetChannel", new { id = channel.PrimaryKey }, channel);
+        }
+
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteChannel([FromRoute] long id)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            var channel = await db.Channels.SingleOrDefaultAsync(m => m.PrimaryKey == id);
+            if (channel == null)
+            {
+                return NotFound();
+            }
+
+            db.Channels.Remove(channel);
+            await db.SaveChangesAsync();
+
+            return Ok(channel);
+        }
+
+        private bool ChannelExists(long id)
+        {
+            return db.Channels.Any(e => e.PrimaryKey == id);
+        }
+    }
+}

YTManager/Controllers/Raw/Private_Video.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using YTManager;
+using YTManager.Models;
+
+namespace YTManager.Controllers
+{
+    [Produces("application/json")]
+    [Route("api_raw/Videos")]
+    public class Private_Videos : Controller
+    {
+        private readonly MediaDB _context;
+
+        public Private_Videos(MediaDB context)
+        {
+            _context = context;
+        }
+
+        // GET: api/Videos
+        [HttpGet]
+        public IEnumerable<Video> GetVideos()
+        {
+            return _context.Videos;
+        }
+
+        // GET: api/Videos/5
+        [HttpGet("{id}")]
+        public async Task<IActionResult> GetVideo([FromRoute] long id)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            var video = await _context
+                .Videos
+                .Include(v => v.Channel)
+                .SingleOrDefaultAsync(m => m.PrimaryKey == id);
+
+            if (video == null)
+            {
+                return NotFound();
+            }
+
+            return Ok(video);
+        }
+
+        // PUT: api/Videos/5
+        [HttpPut("{id}")]
+        public async Task<IActionResult> PutVideo([FromRoute] long id, [FromBody] Video video)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            if (id != video.PrimaryKey)
+            {
+                return BadRequest();
+            }
+
+            _context.Entry(video).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!VideoExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return NoContent();
+        }
+
+        // POST: api/Videos
+        [HttpPost]
+        public async Task<IActionResult> PostVideo([FromBody] Video video)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            _context.Videos.Add(video);
+            await _context.SaveChangesAsync();
+
+            return CreatedAtAction("GetVideo", new { id = video.PrimaryKey }, video);
+        }
+
+        // DELETE: api/Videos/5
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteVideo([FromRoute] long id)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            var video = await _context.Videos.SingleOrDefaultAsync(m => m.PrimaryKey == id);
+            if (video == null)
+            {
+                return NotFound();
+            }
+
+            _context.Videos.Remove(video);
+            await _context.SaveChangesAsync();
+
+            return Ok(video);
+        }
+
+        private bool VideoExists(long id)
+        {
+            return _context.Videos.Any(e => e.PrimaryKey == id);
+        }
+    }
+}

YTManager/Controllers/Videos.cs

@@ -22,7 +22,7 @@ namespace YTManager.Controllers {
             // Thumbnail URL.
             public string Thumbnail;
 
-            // Channel youtube ID.
+            // Channel on youtube that owns this video
             public string Channel;
 
             // Populate this struct using a model video.
@@ -31,7 +31,7 @@ namespace YTManager.Controllers {
                 Description = video.Description;
                 ID = video.YoutubeID;
                 Thumbnail = video.ThumbnailURL;
-                Channel = video.channel?.YoutubeID;
+                Channel = video.Channel.Title;
             }
         }
 
@@ -49,6 +49,7 @@ namespace YTManager.Controllers {
         public async Task<IActionResult> GetVideos() {
             // Get all the relevant videos.
             var vids = await db.Videos
+                .Include(v => v.Channel)
                 .OrderByDescending(i => i.AddedtoDB)
                 .Take(max_per_query)
                 .ToListAsync();
@@ -63,12 +64,12 @@ namespace YTManager.Controllers {
         }
 
         // Returns the most recent videos of a channel.
-        [HttpGet("fromchannel/{channelID}")]
-        public async Task<IActionResult> Get_Channel_Videos([FromRoute] string channelID) {
+        [HttpGet("fromchannel/{channelName}")]
+        public async Task<IActionResult> Get_Channel_Videos([FromRoute] string channelName) {
             // Get all the relevant videos.
             var vids = await db.Videos
-                .Include(v => v.channel)
-                .Where(v => v.channel.YoutubeID == channelID)
+                .Include(v => v.Channel)
+                .Where(v => v.Channel.Title == channelName)
                 .OrderByDescending(i => i.AddedtoDB)
                 .Take(max_per_query)
                 .ToListAsync();