vgquotes/Src/VideoGameQuotes.Web/Controllers/QuoteController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Web.Mvc;
using JetBrains.Annotations;
using Portoa.Persistence;
using Portoa.Web.Controllers;
using Portoa.Web.Results;
using VideoGameQuotes.Api;
using VideoGameQuotes.Web.Models;
using VideoGameQuotes.Web.Security;
using VideoGameQuotes.Web.Services;

namespace VideoGameQuotes.Web.Controllers {
	public class QuoteController : Controller {
		private readonly IQuoteService quoteService;
		private readonly ICurrentUserProvider currentUserProvider;

		public QuoteController(IQuoteService quoteService, ICurrentUserProvider currentUserProvider) {
			this.quoteService = quoteService;
			this.currentUserProvider = currentUserProvider;
		}

		public ActionResult Browse(BrowseModel model) {
			var viewModel = new BrowseViewModel();

			if (model.GameIds.Any()) {
				viewModel.Games = model.GameIds.Select(id => quoteService.GetGame(id));
			}
			if (model.SystemIds.Any()) {
				viewModel.Systems = model.SystemIds.Select(id => quoteService.GetSystem(id));
			}
			if (model.PublisherIds.Any()) {
				viewModel.Publishers = model.PublisherIds.Select(id => quoteService.GetPublisher(id));
			}
			if (model.CategoryIds.Any()) {
				viewModel.Categories = model.CategoryIds.Select(id => quoteService.GetCategory(id));
			}

			if (!viewModel.Games.Any() && !viewModel.Systems.Any() && !viewModel.Categories.Any() && !viewModel.Publishers.Any()) {
				return View("DefaultBrowse");
			}

			return View("QualifiedBrowse", viewModel);
		}

		[HttpPost, IsValidUser]
		public JsonResult Report(ReportModel model) {
			if (!ModelState.IsValid) {
				return Json(this.CreateJsonErrorResponse("Invalid request"));
			}

			try {
				var quote = quoteService.GetQuote(model.QuoteId);
				quote.AddFlag(model.Comment, model.FlagType, currentUserProvider.CurrentUser);
				quoteService.SaveQuote(quote);
				return Json(this.CreateJsonResponse());
			} catch {
				return Json(this.CreateJsonErrorResponse("Unable to create your report"));
			}
		}

		[HttpPost, IsValidUser]
		public JsonResult Vote(VoteModel model) {
			if (!ModelState.IsValid) {
				return Json(this.CreateJsonErrorResponse("Invalid request"));
			}

			try {
				var vote = quoteService.GetVoteOrCreateNew(quoteService.GetQuote(model.QuoteId), currentUserProvider.CurrentUser);
				vote.Direction = model.Direction;

				vote = quoteService.SaveVote(vote);

				var data = new Dictionary<string, string> {
					{ "netVotes", vote.Quote.Score.ToString() },
					{ "upVotes", vote.Quote.UpVotes.ToString() },
					{ "downVotes", vote.Quote.DownVotes.ToString() }
				};

				return Json(this.CreateJsonResponse(null, data));
			} catch {
				return Json(this.CreateJsonErrorResponse("An error occurred while trying to process your vote"));
			}
		}

		public ActionResult Recent() {
			return View(new QuoteCollectionModel {
				Quotes = quoteService.GetMostRecentQuotes(10),
				User = currentUserProvider.CurrentUser
			});
		}

		public ActionResult Best(int start = 0, int end = 19) {
			if (start < 0 || end <= 0 || start > end) {
				return new StatusOverrideResult(View("BadPaging")) { StatusCode = HttpStatusCode.BadRequest };
			}

			return View(new PagedQuoteCollectionModel {
				Quotes = quoteService.GetBestQuotes(start, end),
				User = currentUserProvider.CurrentUser,
				Start = start,
				End = end
			});
		}

		public ActionResult Random() {
			var quote = quoteService.GetRandomQuote();
			if (quote == null) {
				return View("NoQuotes");
			}

			return RedirectToAction("Quote", new { id = quote.Id, text = quote.GetUrlFriendlyText() });
		}

		[IsValidUser]
		public ActionResult Submit() {
			var model = new QuoteSubmitModel();
			ResetModel(model);
			return View(model);
		}

		[HttpPost, IsValidUser]
		public ActionResult Submit(QuoteSubmitModel model) {
			if (!ModelState.IsValid) {
				ResetModel(model);
				return View(model);
			}

			try {
				var quote = new Quote {
					Creator = currentUserProvider.CurrentUser,
					Game = GetGameFromModelData(model),
					Text = model.QuoteText
				};

				if (model.CategoryIds != null && model.CategoryIds.Count > 0) {
					quote.ClearCategories();
					foreach (var categoryId in model.CategoryIds) {
						quote.AddCategory(quoteService.GetCategory(categoryId));
					}
				}

				if (quote.Game == null) {
					ResetModel(model);
					return View(model);
				}

				quote = quoteService.SaveQuote(quote);

				return RedirectToAction("Quote", new { id = quote.Id, text = quote.GetUrlFriendlyText() });
			} catch (Exception e) {
				ModelState.AddModelError("save", e.Message);
				ResetModel(model);
				return View(model);
			}
		}

		[CanBeNull]
		private Game GetGameFromModelData(QuoteSubmitModel model) {
			if (model.GameId > 0) {
				try {
					return quoteService.GetGame(model.GameId);
				} catch {
					throw new Exception("Unable to find game with ID " + model.GameId);
				}
			}

			if (string.IsNullOrEmpty(model.GameName)) {
				ModelState.AddModelError("GameName", "Game name must be non-empty");
				return null;
			}

			//construct game from model data
			var game = new Game {
				Name = model.GameName,
				Region = model.GameRegions,
				Website = model.GameWebsite,
				Creator = currentUserProvider.CurrentUser
			};

			//publishers
			if ((model.PublisherIds != null && model.PublisherIds.Count > 0) || !string.IsNullOrEmpty(model.PublisherName)) {
				//modifying publishers, so remove errthing
				game.ClearPublishers();

				if (model.PublisherIds != null && model.PublisherIds.Count > 0) {
					foreach (var publisherId in model.PublisherIds) {
						game.AddPublisher(quoteService.GetPublisher(publisherId));
					}
				}

				if (!string.IsNullOrEmpty(model.PublisherName)) {
					game.AddPublisher(new Publisher {
						Name = model.PublisherName,
						Website = model.PublisherWebsite
					});
				}
			}

			//systems
			if ((model.SystemIds != null && model.SystemIds.Count > 0) || !string.IsNullOrEmpty(model.SystemName)) {
				//modifying systems, so remove errthing
				game.ClearSystems();

				if (model.SystemIds != null && model.SystemIds.Count > 0) {
					foreach (var systemId in model.SystemIds) {
						game.AddSystem(quoteService.GetSystem(systemId));
					}
				}

				if (!string.IsNullOrEmpty(model.SystemName)) {
					game.AddSystem(new GamingSystem {
						Name = model.SystemName,
						Abbreviation = model.SystemAbbreviation,
						ReleaseDate = model.SystemReleaseDate
					});
				}
			}

			return game;
		}

		private void ResetModel(QuoteSubmitModel model) {
			model.AllGames = quoteService.GetAllGames().OrderBy(game => game.Name);
			model.AllSystems = quoteService.GetAllSystems().OrderBy(system => system.ReleaseDate);
			model.AllPublishers = quoteService.GetAllPublishers();
			model.AllCategories = quoteService.GetAllCategories();
		}

		public ActionResult Quote(int id) {
			try {
				var model = new QuoteModel {
					Quote = quoteService.GetQuote(id),
					User = currentUserProvider.CurrentUser
				};

				return View(model);
			} catch (EntityNotFoundException) {
				return new StatusOverrideResult(View("QuoteNotFound")) { StatusCode = HttpStatusCode.NotFound };
			}
		}

		[HttpPost]
		public JsonResult CreateCategory(Category category) {
			try {
				category = quoteService.SaveCategory(category);
				var data = new Dictionary<string, string> { { "categoryId", category.Id.ToString() }, { "categoryName", category.Name } };
				return Json(this.CreateJsonResponse(null, data));
			} catch (Exception e) {
				return Json(this.CreateJsonErrorResponse(e));
			}
		}
	}
}