Preparation fo Mystery rolling

ALttPRandomizer/SeedController.cs

@@ -1,26 +1,45 @@
 namespace ALttPRandomizer {
+    using ALttPRandomizer.Serialization;
     using ALttPRandomizer.Model;
+    using ALttPRandomizer.Randomizers;
     using ALttPRandomizer.Service;
     using ALttPRandomizer.Settings;
     using Microsoft.AspNetCore.Mvc;
     using Microsoft.Extensions.Logging;
     using System.Collections.Generic;
     using System.Threading.Tasks;
+    using YamlDotNet.Serialization;
+    using YamlDotNet.Serialization.NamingConventions;
 
     public class SeedController : Controller {
-        public SeedController(RandomizeService randomizeService, SeedService seedService, ILogger<SeedController> logger) {
+        public SeedController(
+                RandomizeService randomizeService,
+                MysteryRandomizer mysteryRandomizer,
+                SeedService seedService,
+                ILogger<SeedController> logger) {
             this.RandomizeService = randomizeService;
+            this.MysteryRandomizer = mysteryRandomizer;
             this.SeedService = seedService;
             this.Logger = logger;
+
+            this.YamlSerializer =
+                new SerializerBuilder()
+                    .WithNamingConvention(UnderscoredNamingConvention.Instance)
+                    .WithTypeConverter(new YamlStringEnumConverter())
+                    .WithTypeConverter(new RandomizableWeightsYamlConverters())
+                    .ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull | DefaultValuesHandling.OmitEmptyCollections)
+                    .Build();
         }
 
         private RandomizeService RandomizeService { get; }
+        private MysteryRandomizer MysteryRandomizer { get; }
         private SeedService SeedService { get; }
         private ILogger<SeedController> Logger { get; }
+        private ISerializer YamlSerializer { get; }
 
         [Route("/generate")]
         [HttpPost]
-        public async Task<ActionResult> Generate([FromBody] SeedSettings settings) {
+        public async Task<ObjectResult> Generate([FromBody] SeedSettings settings) {
             if (!ModelState.IsValid) {
                 return BadRequest(ModelState);
             }
@@ -33,9 +52,22 @@
             }
         }
 
+        [Route("/mystery/{randomizer}")]
+        [HttpPost]
+        public ActionResult RollMystery([FromBody] MysterySettings mysterySettings, RandomizerInstance randomizer) {
+            if (!ModelState.IsValid) {
+                return BadRequest(ModelState);
+            }
+
+            var seedSettings = new SeedSettings() { Randomizer = randomizer };
+            this.MysteryRandomizer.Roll(mysterySettings, seedSettings);
+
+            return StatusCode(200, this.YamlSerializer.Serialize(mysterySettings));
+        }
+
         [Route("/multiworld")]
         [HttpPost]
-        public async Task<ActionResult> GenerateMultiworld([FromBody] IList<SeedSettings> settings) {
+        public async Task<ObjectResult> GenerateMultiworld([FromBody] IList<SeedSettings> settings) {
             if (!ModelState.IsValid) {
                 return BadRequest(ModelState);
             }
@@ -50,25 +82,25 @@
 
         [Route("/seed/{id}")]
         [HttpGet]
-        public async Task<ActionResult> GetSeed(string id) {
+        public async Task<ObjectResult> GetSeed(string id) {
             return ResolveResult(await this.SeedService.GetSeed(id));
         }
 
         [Route("/seed/{id}")]
         [HttpPost]
-        public async Task<ActionResult> RetrySeed(string id) {
+        public async Task<ObjectResult> RetrySeed(string id) {
             return ResolveResult(await this.RandomizeService.RetrySeed(id));
         }
 
         [Route("/multi/{id}")]
         [HttpGet]
-        public async Task<ActionResult> GetMulti(string id) {
+        public async Task<ObjectResult> GetMulti(string id) {
             return ResolveResult(await this.SeedService.GetMulti(id));
         }
 
         [Route("/multi/{id}")]
         [HttpPost]
-        public async Task<ActionResult> RetryMulti(string id) {
+        public async Task<ObjectResult> RetryMulti(string id) {
             return ResolveResult(await this.RandomizeService.RetryMulti(id));
         }
 
@@ -85,7 +117,7 @@
             }
         }
 
-        private ActionResult ResolveResult(IDictionary<string, object> result) {
+        private ObjectResult ResolveResult(IDictionary<string, object> result) {
             if (result.TryGetValue("status", out var responseCode)) {
                 if (responseCode is int code) {
                     return StatusCode(code, result);