Removed NioTSO client and server

- NioTSO client isn't needed because we're using RayLib
- Added FreeSO's API server to handle most backend operations

server/FSO.Server.Api.Core/Api.cs

@@ -0,0 +1,281 @@
+using FSO.Server.Api.Core.Services;
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Common;
+using FSO.Server.Common.Config;
+using FSO.Server.Database.DA;
+using FSO.Server.Domain;
+using FSO.Server.Servers.Api.JsonWebToken;
+using Microsoft.AspNetCore.Http;
+using System;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Security;
+
+namespace FSO.Server.Api.Core
+{
+    public class Api : ApiAbstract
+    {
+        public static Api INSTANCE;
+
+        public IDAFactory DAFactory;
+        public ApiConfig Config;
+        public JWTFactory JWT;
+        public Shards Shards;
+        public IGluonHostPool HostPool;
+        public IUpdateUploader UpdateUploader;
+        public IUpdateUploader UpdateUploaderClient;
+        public GithubConfig Github;
+
+        public Api()
+        {
+            INSTANCE = this;
+        }
+
+        public void Init(NameValueCollection appSettings)
+        {
+            Config = new ApiConfig();
+            Config.Maintainance = bool.Parse(appSettings["maintainance"]);
+            Config.AuthTicketDuration = int.Parse(appSettings["authTicketDuration"]);
+            Config.Regkey = appSettings["regkey"];
+            Config.Secret = appSettings["secret"];
+            Config.UpdateUrl = appSettings["updateUrl"];
+            Config.CDNUrl = appSettings["cdnUrl"];
+            Config.NFSdir = appSettings["nfsdir"];
+            Config.UseProxy = bool.Parse(appSettings["useProxy"]);
+            Config.UpdateID = (appSettings["updateID"] == "") ? (int?)null : int.Parse(appSettings["updateID"]);
+            Config.BranchName = appSettings["branchName"] ?? "beta";
+
+            // new smtp config vars
+            if (appSettings["smtpHost"]!=null&&
+                appSettings["smtpUser"]!=null&&
+                appSettings["smtpPassword"]!=null&&
+                appSettings["smtpPort"]!=null)
+            {
+                Config.SmtpEnabled = true;
+                Config.SmtpHost = appSettings["smtpHost"];
+                Config.SmtpUser = appSettings["smtpUser"];
+                Config.SmtpPassword = appSettings["smtpPassword"];
+                Config.SmtpPort = int.Parse(appSettings["smtpPort"]);
+            }
+
+            JWT = new JWTFactory(new JWTConfiguration()
+            {
+                Key = System.Text.UTF8Encoding.UTF8.GetBytes(Config.Secret)
+            });
+
+            DAFactory = new MySqlDAFactory(new Database.DatabaseConfiguration()
+            {
+                ConnectionString = appSettings["connectionString"]
+            });
+            
+            Shards = new Shards(DAFactory);
+            Shards.AutoUpdate();
+        }
+
+        public JWTUser RequireAuthentication(HttpRequest request)
+        {
+            JWTUser result;
+            
+            if (!string.IsNullOrEmpty(request.Headers["Authorization"]))
+            {
+                result = JWT.DecodeToken(GetAuthParam(request.Headers["Authorization"]));
+            }
+            else
+            {
+                var cookies = request.Cookies;
+                if (cookies == null)
+                    throw new SecurityException("Unable to find cookie");
+
+
+                var cookie = cookies["fso"];
+                if (string.IsNullOrEmpty(cookie))
+                {
+                    throw new SecurityException("Unable to find cookie");
+                }
+                result = JWT.DecodeToken(cookie);
+            }
+            if (result == null)
+            {
+                throw new SecurityException("Invalid token");
+            }
+
+            return result;
+        }
+
+        public string GetAuthParam(string auth)
+        {
+            var ind = auth.IndexOf(' ');
+            if (ind == -1) return auth;
+            return auth.Substring(ind + 1);
+        }
+
+        /// <summary>
+        /// Sends an email to a user to tell them that they're banned. ;(
+        /// </summary>
+        /// <param name="username"></param>
+        /// <param name="email"></param>
+        /// <param name="end_date"></param>
+        public void SendBanMail(string username, string email, uint end_date)
+        {
+            ApiMail banMail = new ApiMail("MailBan");
+
+            var date = end_date == 0 ? "Permanent ban" : Epoch.ToDate(end_date).ToString();
+
+            banMail.AddString("username", username);
+            banMail.AddString("end", date);
+
+            banMail.Send(email, "Banned from ingame");
+        }
+
+        /// <summary>
+        /// Sends an email to a user saying that the registration went OK.
+        /// </summary>
+        /// <param name="username"></param>
+        /// <param name="email"></param>
+        public void SendEmailConfirmationOKMail(string username, string email)
+        {
+            ApiMail confirmOKMail = new ApiMail("MailRegistrationOK");
+
+            confirmOKMail.AddString("username", username);
+
+            confirmOKMail.Send(email, "Welcome to FreeSO, " + username + "!");
+        }
+
+        /// <summary>
+        /// Sends an email to a a new user with a token to create their user.
+        /// </summary>
+        /// <param name="email"></param>
+        /// <param name="token"></param>
+        /// <param name="confirmation_url"></param>
+        /// <param name="expires"></param>
+        /// <returns></returns>
+        public bool SendEmailConfirmationMail(string email, string token, string confirmation_url, uint expires)
+        {
+            ApiMail confirmMail = new ApiMail("MailRegistrationToken");
+
+            confirmation_url = confirmation_url.Replace("%token%", token);
+            confirmMail.AddString("token", token);
+            confirmMail.AddString("expires", Epoch.HMSRemaining(expires));
+            confirmMail.AddString("confirmation_url", confirmation_url);
+
+            return confirmMail.Send(email, "Verify your FreeSO account");
+        }
+
+        /// <summary>
+        /// Sends an email to a user with a token to reset their password.
+        /// </summary>
+        /// <param name="email"></param>
+        /// <param name="username"></param>
+        /// <param name="token"></param>
+        /// <param name="confirmation_url"></param>
+        /// <param name="expires"></param>
+        /// <returns></returns>
+        public bool SendPasswordResetMail(string email, string username, string token, string confirmation_url, uint expires)
+        {
+            ApiMail confirmMail = new ApiMail("MailPasswordReset");
+
+            confirmation_url = confirmation_url.Replace("%token%", token);
+            confirmMail.AddString("token", token);
+            confirmMail.AddString("expires", Epoch.HMSRemaining(expires));
+            confirmMail.AddString("confirmation_url", confirmation_url);
+
+            return confirmMail.Send(email, "Password Reset for " + username);
+        }
+
+        /// <summary>
+        /// Sends a password change success email to a user.
+        /// </summary>
+        /// <param name="email"></param>
+        /// <param name="username"></param>
+        /// <returns></returns>
+        public bool SendPasswordResetOKMail(string email, string username)
+        {
+            ApiMail confirmMail = new ApiMail("MailPasswordResetOK");
+
+            confirmMail.AddString("username", username);
+
+            return confirmMail.Send(email, "Your account password was reset");
+        }
+
+        public void DemandModerator(JWTUser user)
+        {
+            if (!user.Claims.Contains("moderator")) throw new Exception("Requires Moderator level status");
+        }
+
+        public void DemandAdmin(JWTUser user)
+        {
+            if (!user.Claims.Contains("admin")) throw new Exception("Requires Admin level status");
+        }
+
+        public void DemandModerator(HttpRequest request)
+        {
+            DemandModerator(RequireAuthentication(request));
+        }
+
+        public void DemandAdmin(HttpRequest request)
+        {
+            DemandAdmin(RequireAuthentication(request));
+        }
+
+        /// <summary>
+        /// Changes a user's password.
+        /// </summary>
+        /// <param name="user_id"></param>
+        /// <param name="new_password"></param>
+        public void ChangePassword(uint user_id, string new_password)
+        {
+            using (var da = DAFactory.Get())
+            {
+                var passhash = PasswordHasher.Hash(new_password);
+                var authSettings = new Database.DA.Users.UserAuthenticate();
+                authSettings.scheme_class = passhash.scheme;
+                authSettings.data = passhash.data;
+                authSettings.user_id = user_id;
+
+                da.Users.UpdateAuth(authSettings);
+            }
+        }
+
+        /// <summary>
+        /// Inserts a brand new user in db.
+        /// </summary>
+        /// <param name="username"></param>
+        /// <param name="email"></param>
+        /// <param name="password"></param>
+        /// <param name="ip"></param>
+        /// <returns></returns>
+        public Database.DA.Users.User CreateUser(string username, string email, string password, string ip)
+        {
+            using (var da = DAFactory.Get())
+            {
+                var userModel = new Database.DA.Users.User();
+                userModel.username = username;
+                userModel.email = email;
+                userModel.is_admin = false;
+                userModel.is_moderator = false;
+                userModel.user_state = Database.DA.Users.UserState.valid;
+                userModel.register_date = Epoch.Now;
+                userModel.is_banned = false;
+                userModel.register_ip = ip;
+                userModel.last_ip = ip;
+
+                var passhash = PasswordHasher.Hash(password);
+                var authSettings = new Database.DA.Users.UserAuthenticate();
+                authSettings.scheme_class = passhash.scheme;
+                authSettings.data = passhash.data;
+
+                try
+                {
+                    var userId = da.Users.Create(userModel);
+                    authSettings.user_id = userId;
+                    da.Users.CreateAuth(authSettings);
+                    return da.Users.GetById(userId);
+                }
+                catch (Exception)
+                {
+                    return null;
+                }
+            }
+        }
+    }
+}

server/FSO.Server.Api.Core/ApiConfig.cs

@@ -0,0 +1,42 @@
+using FSO.Server.Api.Core.Services;
+
+namespace FSO.Server.Api.Core
+{
+    public class ApiConfig
+    {
+        /// <summary>
+        /// How long an auth ticket is valid for
+        /// </summary>
+        public int AuthTicketDuration = 300;
+
+        /// <summary>
+        /// If non-null, the user must provide this key to register an account.
+        /// </summary>
+        public string Regkey { get; set; }
+
+        /// <summary>
+        /// If true, only authentication from moderators and admins will be accepted
+        /// </summary>
+        public bool Maintainance { get; set; }
+
+        public string Secret { get; set; }
+
+        public string UpdateUrl { get; set; }
+        public string CDNUrl { get; set; }
+
+        public string NFSdir { get; set; }
+
+        public string SmtpHost { get; set; }
+        public int SmtpPort { get; set; }
+        public string SmtpPassword { get; set; }
+        public string SmtpUser { get; set; }
+
+        public bool SmtpEnabled { get; set;  }
+        public bool UseProxy { get; set; }
+
+        public int? UpdateID { get; set; }
+
+        public string BranchName { get; set; } = "dev";
+        public IUpdateUploader UpdateUploader { get; set; }
+    }
+}

server/FSO.Server.Api.Core/Controllers/Admin/AdminEventsController.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Linq;
+using System.Net;
+using FSO.Server.Api.Core.Models;
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Database.DA.DbEvents;
+using FSO.Server.Database.DA.Tuning;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+
+// For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
+
+namespace FSO.Server.Api.Core.Controllers.Admin
+{
+    [EnableCors("AdminAppPolicy")]
+    [Route("admin/events")]
+    [ApiController]
+    public class AdminEventsController : ControllerBase
+    {
+        //List events
+        [HttpGet]
+        public IActionResult Get(int limit, int offset, string order)
+        {
+            if (limit == 0) limit = 20;
+            if (order == null) order = "start_day";
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+            using (var da = api.DAFactory.Get())
+            {
+
+                if (limit > 100)
+                {
+                    limit = 100;
+                }
+
+                var result = da.Events.All((int)offset, (int)limit, order);
+                return ApiResponse.PagedList<DbEvent>(Request, HttpStatusCode.OK, result);
+            }
+        }
+
+        [HttpGet("presets")]
+        public IActionResult GetPresets()
+        {
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+            using (var da = api.DAFactory.Get())
+            {
+                return new JsonResult(da.Tuning.GetAllPresets().ToList());
+            }
+        }
+
+        [HttpPost("presets")]
+        public IActionResult CreatePreset([FromBody]PresetCreateModel request)
+        {
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+            using (var da = api.DAFactory.Get())
+            {
+                //make the preset first
+                var preset_id = da.Tuning.CreatePreset(
+                    new DbTuningPreset()
+                    {
+                        name = request.name,
+                        description = request.description,
+                        flags = request.flags
+                    });
+
+                foreach (var item in request.items)
+                {
+                    da.Tuning.CreatePresetItem(new DbTuningPresetItem()
+                    {
+                        preset_id = preset_id,
+                        tuning_type = item.tuning_type,
+                        tuning_table = item.tuning_table,
+                        tuning_index = item.tuning_index,
+                        value = item.value
+                    });
+                }
+                return new JsonResult(da.Tuning.GetAllPresets().ToList());
+            }
+        }
+
+        [HttpGet("presets/{preset_id}")]
+        public IActionResult GetPresetEntries(int preset_id)
+        {
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+            using (var da = api.DAFactory.Get())
+            {
+                return new JsonResult(da.Tuning.GetPresetItems(preset_id).ToList());
+            }
+        }
+
+        [HttpDelete("presets/{preset_id}")]
+        public IActionResult DeletePreset(int preset_id)
+        {
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+            using (var da = api.DAFactory.Get())
+            {
+                return da.Tuning.DeletePreset(preset_id) ? (IActionResult)Ok() : NotFound();
+            }
+        }
+
+        // POST admin/updates (start update generation)
+        [HttpPost]
+        public IActionResult Post([FromBody]EventCreateModel request)
+        {
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+
+            using (var da = api.DAFactory.Get())
+            {
+                DbEventType type;
+                try
+                {
+                    type = Enum.Parse<DbEventType>(request.type);
+                }
+                catch
+                {
+                    return BadRequest("Event type must be one of:" + string.Join(", ", Enum.GetNames(typeof(DbEventType))));
+                }
+                var model = new DbEvent()
+                {
+                    title = request.title,
+                    description = request.description,
+                    start_day = request.start_day,
+                    end_day = request.end_day,
+                    type = type,
+                    value = request.value,
+                    value2 = request.value2,
+                    mail_subject = request.mail_subject,
+                    mail_message = request.mail_message,
+                    mail_sender = request.mail_sender,
+                    mail_sender_name = request.mail_sender_name
+                };
+                return new JsonResult(new { id = da.Events.Add(model) });
+            }
+        }
+
+        [HttpDelete]
+        [Route("{id}")]
+        public IActionResult Delete(int id)
+        {
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+
+            using (var da = api.DAFactory.Get())
+            {
+                if (!da.Events.Delete(id)) return NotFound();
+            }
+
+            return Ok();
+        }
+
+    }
+}

server/FSO.Server.Api.Core/Controllers/Admin/AdminHostsController.cs

@@ -0,0 +1,30 @@
+using FSO.Server.Api.Core.Utils;
+using System.Net;
+using System.Linq;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Cors;
+
+namespace FSO.Server.Api.Core.Controllers.Admin
+{
+    [EnableCors("AdminAppPolicy")]
+    [Route("admin/hosts")]
+    [ApiController]
+    public class AdminHostsController : ControllerBase
+    {
+        public IActionResult Get()
+        {
+            var api = Api.INSTANCE;
+            api.DemandAdmin(Request);
+            var hosts = api.HostPool.GetAll();
+
+            return ApiResponse.Json(HttpStatusCode.OK, hosts.Select(x => new {
+                role = x.Role,
+                call_sign = x.CallSign,
+                internal_host = x.InternalHost,
+                public_host = x.PublicHost,
+                connected = x.Connected,
+                time_boot = x.BootTime
+            }));
+        }
+    }
+}

server/FSO.Server.Api.Core/Controllers/Admin/AdminOAuthController.cs

@@ -0,0 +1,129 @@
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Common;
+using FSO.Server.Servers.Api.JsonWebToken;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Collections.Generic;
+
+namespace FSO.Server.Api.Core.Controllers.Admin
+{
+    [EnableCors("AdminAppPolicy")]
+    [Route("admin/oauth/token")]
+    [ApiController]
+    public class AdminOAuthController : ControllerBase
+    {
+        [HttpPost]
+        public IActionResult Post([FromForm] AuthRequest auth)
+        {
+            if (auth == null) Ok();
+            if (auth.grant_type == "password")
+            {
+                var api = Api.INSTANCE;
+                using (var da = api.DAFactory.Get())
+                {
+                    var user = da.Users.GetByUsername(auth.username);
+                    if (user == null || user.is_banned || !(user.is_admin || user.is_moderator))
+                    {
+                        return ApiResponse.Json(System.Net.HttpStatusCode.OK, new OAuthError
+                        {
+                            error = "unauthorized_client",
+                            error_description = "user_credentials_invalid"
+                        });
+                    }
+
+                    var ip = ApiUtils.GetIP(Request);
+                    var accLock = da.Users.GetRemainingAuth(user.user_id, ip);
+                    if (accLock != null && (accLock.active || accLock.count >= AuthLoginController.LockAttempts) && accLock.expire_time > Epoch.Now)
+                    {
+                        return ApiResponse.Json(System.Net.HttpStatusCode.OK, new OAuthError
+                        {
+                            error = "unauthorized_client",
+                            error_description = "account_locked"
+                        });
+                    }
+
+                    var authSettings = da.Users.GetAuthenticationSettings(user.user_id);
+                    var isPasswordCorrect = PasswordHasher.Verify(auth.password, new PasswordHash
+                    {
+                        data = authSettings.data,
+                        scheme = authSettings.scheme_class
+                    });
+
+                    if (!isPasswordCorrect)
+                    {
+                        var durations = AuthLoginController.LockDuration;
+                        var failDelay = 60 * durations[Math.Min(durations.Length - 1, da.Users.FailedConsecutive(user.user_id, ip))];
+                        if (accLock == null)
+                        {
+                            da.Users.NewFailedAuth(user.user_id, ip, (uint)failDelay);
+                        }
+                        else
+                        {
+                            var remaining = da.Users.FailedAuth(accLock.attempt_id, (uint)failDelay, AuthLoginController.LockAttempts);
+                        }
+
+                        return ApiResponse.Json(System.Net.HttpStatusCode.OK, new OAuthError
+                        {
+                            error = "unauthorized_client",
+                            error_description = "user_credentials_invalid"
+                        });
+                    }
+
+                    da.Users.SuccessfulAuth(user.user_id, ip);
+
+                    JWTUser identity = new JWTUser();
+                    identity.UserName = user.username;
+                    var claims = new List<string>();
+                    if (user.is_admin || user.is_moderator)
+                    {
+                        claims.Add("moderator");
+                    }
+                    if (user.is_admin)
+                    {
+                        claims.Add("admin");
+                    }
+
+                    identity.Claims = claims;
+                    identity.UserID = user.user_id;
+
+                    var token = api.JWT.CreateToken(identity);
+
+                    var response = ApiResponse.Json(System.Net.HttpStatusCode.OK, new OAuthSuccess
+                    {
+                        access_token = token.Token,
+                        expires_in = token.ExpiresIn
+                    });
+
+                    return response;
+                }
+            }
+
+            return ApiResponse.Json(System.Net.HttpStatusCode.OK, new OAuthError
+            {
+                error = "invalid_request",
+                error_description = "unknown grant_type"
+            });
+        }
+    }
+
+
+    public class OAuthError
+    {
+        public string error_description { get; set; }
+        public string error { get; set; }
+    }
+
+    public class OAuthSuccess
+    {
+        public string access_token { get; set; }
+        public int expires_in { get; set; }
+    }
+
+    public class AuthRequest
+    {
+        public string grant_type { get; set; }
+        public string username { get; set; }
+        public string password { get; set; }
+    }
+}

server/FSO.Server.Api.Core/Controllers/Admin/AdminShardsController.cs

@@ -0,0 +1,69 @@
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Common;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using System.Net;
+
+namespace FSO.Server.Api.Core.Controllers.Admin
+{
+    [EnableCors("AdminAppPolicy")]
+    [Route("admin/shards")]
+    [ApiController]
+    public class AdminShardsController : ControllerBase
+    {
+        [HttpGet]
+        public IActionResult Get()
+        {
+            var api = Api.INSTANCE;
+            api.DemandAdmin(Request);
+
+            using (var db = api.DAFactory.Get())
+            {
+                var shards = db.Shards.All();
+                return ApiResponse.Json(HttpStatusCode.OK, shards);
+            }
+        }
+
+        [HttpPost("shutdown")]
+        public IActionResult shutdown(ShutdownModel sd)
+        {
+            var api = Api.INSTANCE;
+            api.DemandAdmin(Request);
+
+            ShutdownType type = ShutdownType.SHUTDOWN;
+            if (sd.update) type = ShutdownType.UPDATE;
+            else if (sd.restart) type = ShutdownType.RESTART;
+
+            api.RequestShutdown((uint)sd.timeout, type);
+
+            return ApiResponse.Json(HttpStatusCode.OK, true);
+        }
+
+        [HttpPost("announce")]
+        public IActionResult announce(AnnouncementModel an)
+        {
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+
+            api.BroadcastMessage(an.sender, an.subject, an.message);
+
+            return ApiResponse.Json(HttpStatusCode.OK, true);
+        }
+    }
+
+    public class AnnouncementModel
+    {
+        public string sender;
+        public string subject;
+        public string message;
+        public int[] shard_ids;
+    }
+
+    public class ShutdownModel
+    {
+        public int timeout;
+        public bool restart;
+        public bool update;
+        public int[] shard_ids;
+    }
+}

server/FSO.Server.Api.Core/Controllers/Admin/AdminTasksController.cs

@@ -0,0 +1,73 @@
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Database.DA.Tasks;
+using FSO.Server.Protocol.Gluon.Packets;
+using Newtonsoft.Json;
+using System;
+using System.Net;
+using System.Linq;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Cors;
+
+namespace FSO.Server.Api.Core.Controllers.Admin
+{
+    [EnableCors("AdminAppPolicy")]
+    [Route("admin/tasks")]
+    [ApiController]
+    public class AdminTasksController : ControllerBase
+    {
+        [HttpGet]
+        public IActionResult Get(int limit, int offset)
+            {
+            var api = Api.INSTANCE;
+                api.DemandAdmin(Request);
+
+                using (var da = api.DAFactory.Get())
+                {
+
+                    if (limit > 100)
+                    {
+                        limit = 100;
+                    }
+
+                    var result = da.Tasks.All((int)offset, (int)limit);
+                    return ApiResponse.PagedList<DbTask>(Request, HttpStatusCode.OK, result);
+                }
+            }
+
+        [HttpPost("request")]
+        public IActionResult request([FromBody] TaskRequest task)
+        {
+            var api = Api.INSTANCE;
+            api.DemandAdmin(Request);
+
+            var taskServer = api.HostPool.GetByRole(Database.DA.Hosts.DbHostRole.task).FirstOrDefault();
+            if (taskServer == null)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, -1);
+            }
+            else
+            {
+                try
+                {
+                    var id = taskServer.Call(new RequestTask()
+                    {
+                        TaskType = task.task_type.ToString(),
+                        ParameterJson = JsonConvert.SerializeObject(task.parameter),
+                        ShardId = (task.shard_id == null || !task.shard_id.HasValue) ? -1 : task.shard_id.Value
+                    }).Result;
+                    return ApiResponse.Json(HttpStatusCode.OK, id);
+                }
+                catch (Exception ex)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, -1);
+                }
+            }
+        }
+    }
+    public class TaskRequest
+    {
+        public DbTaskType task_type;
+        public int? shard_id;
+        public dynamic parameter;
+    }
+}

server/FSO.Server.Api.Core/Controllers/Admin/AdminUpdatesController.cs

@@ -0,0 +1,172 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using FSO.Server.Api.Core.Models;
+using FSO.Server.Api.Core.Services;
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Database.DA.Updates;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
+
+namespace FSO.Server.Api.Core.Controllers.Admin
+{
+    [EnableCors("AdminAppPolicy")]
+    [Route("admin/updates")]
+    public class AdminUpdatesController : ControllerBase
+    {
+        //List updates
+        [HttpGet]
+        public IActionResult Get(int limit, int offset, string order)
+        {
+            if (limit == 0) limit = 20;
+            if (order == null) order = "date";
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+            using (var da = api.DAFactory.Get())
+            {
+
+                if (limit > 100)
+                {
+                    limit = 100;
+                }
+
+                var result = da.Updates.All((int)offset, (int)limit);
+                return ApiResponse.PagedList<DbUpdate>(Request, HttpStatusCode.OK, result);
+            }
+        }
+
+
+        // GET all branches
+        [HttpGet("branches")]
+        public IActionResult GetBranches()
+        {
+            var api = Api.INSTANCE;
+            api.DemandAdmin(Request);
+            using (var da = api.DAFactory.Get())
+            {
+                return new JsonResult(da.Updates.GetBranches().ToList());
+            }
+        }
+
+        // GET all addons
+        [HttpGet("addons")]
+        public IActionResult GetAddons()
+        {
+            var api = Api.INSTANCE;
+            api.DemandAdmin(Request);
+            using (var da = api.DAFactory.Get())
+            {
+                return new JsonResult(da.Updates.GetAddons(20).ToList());
+            }
+        }
+
+        // POST create a branch.
+        [HttpPost("branches")]
+        public IActionResult AddBranch(DbUpdateBranch branch)
+        {
+            var api = Api.INSTANCE;
+            api.DemandAdmin(Request);
+            using (var da = api.DAFactory.Get())
+            {
+                if (da.Updates.AddBranch(branch)) return Ok();
+                else return NotFound();
+            }
+        }
+
+        // POST update a branch.
+        [HttpPost("branches/{id}")]
+        public IActionResult UpdateBranch(DbUpdateBranch branch)
+        {
+            var api = Api.INSTANCE;
+            api.DemandAdmin(Request);
+            using (var da = api.DAFactory.Get())
+            {
+                if (da.Updates.UpdateBranchInfo(branch)) return Ok();
+                else return NotFound();
+            }
+        }
+
+        public class AddonUploadModel
+        {
+            public string name { get; set; }
+            public string description { get; set; }
+            public IFormFile clientAddon { get; set; }
+            public IFormFile serverAddon { get; set; }
+        }
+
+        static int AddonRequestID = 0;
+        [HttpPost("uploadaddon")]
+        [DisableRequestSizeLimit]
+        [RequestFormLimits(MultipartBodyLengthLimit = 500000000)]
+        public async Task<IActionResult> UploadAddon(AddonUploadModel upload)
+        {
+            var api = Api.INSTANCE;
+            api.DemandAdmin(Request);
+            var reqID = ++AddonRequestID;
+
+            var info = new DbUpdateAddon();
+            if (upload.name == null || upload.name.Length > 128) return BadRequest("Invalid name.");
+            if (upload.description == null || upload.description.Length > 1024) return BadRequest("Invalid description.");
+            info.name = upload.name;
+            info.description = upload.description;
+            info.date = DateTime.UtcNow;
+
+            if (upload.clientAddon == null && upload.serverAddon == null)
+                return BadRequest("client or server addon binary must be uploaded.");
+
+            var addonID = DateTime.UtcNow.Ticks;
+            Directory.CreateDirectory("updateTemp/addons/");
+            if (upload.clientAddon != null)
+            {
+                using (var file = System.IO.File.Open($"updateTemp/addons/client{reqID}.zip", FileMode.Create, FileAccess.Write, FileShare.None))
+                {
+                    await upload.clientAddon.CopyToAsync(file);
+                }
+                info.addon_zip_url = await api.UpdateUploader.UploadFile($"addons/client{addonID}.zip", $"updateTemp/addons/client{reqID}.zip", $"addon-{addonID}");
+                System.IO.File.Delete($"updateTemp/addons/client{reqID}.zip");
+            }
+
+            if (upload.serverAddon != null)
+            {
+                using (var file = System.IO.File.Open($"updateTemp/addons/server{reqID}.zip", FileMode.Create, FileAccess.Write, FileShare.None))
+                {
+                    await upload.serverAddon.CopyToAsync(file);
+                }
+                info.server_zip_url = await api.UpdateUploader.UploadFile($"addons/server{addonID}.zip", $"updateTemp/addons/server{reqID}.zip", $"addon-{addonID}");
+                System.IO.File.Delete($"updateTemp/addons/server{reqID}.zip");
+            }
+
+            using (var da = api.DAFactory.Get())
+            {
+                da.Updates.AddAddon(info);
+                return new JsonResult(info);
+            }
+        }
+
+        // GET status for ongoing update generation
+        [HttpGet("updateTask/{id}")]
+        public IActionResult GetTask(int id)
+        {
+            var api = Api.INSTANCE;
+            api.DemandAdmin(Request);
+            var task = GenerateUpdateService.INSTANCE.GetTask(id);
+            if (task == null) return NotFound();
+            else return new JsonResult(task);
+        }
+
+        // POST admin/updates (start update generation)
+        [HttpPost]
+        public IActionResult Post([FromBody]UpdateCreateModel request)
+        {
+            var api = Api.INSTANCE;
+            api.DemandAdmin(Request);
+            var task = GenerateUpdateService.INSTANCE.CreateTask(request);
+            return new JsonResult(task);
+        }
+    }
+}

server/FSO.Server.Api.Core/Controllers/Admin/AdminUsersController.cs

@@ -0,0 +1,334 @@
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Common;
+using FSO.Server.Database.DA.Inbox;
+using FSO.Server.Database.DA.Users;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Net;
+
+namespace FSO.Server.Api.Core.Controllers.Admin
+{
+    [EnableCors("AdminAppPolicy")]
+    [Route("admin/users")]
+    [ApiController]
+    public class AdminUsersController : ControllerBase
+    {
+        //Get information about me, useful for the admin user interface to disable UI based on who you login as
+        public IActionResult current()
+        {
+            var api = Api.INSTANCE;
+
+            var user = api.RequireAuthentication(Request);
+
+            using (var da = api.DAFactory.Get())
+            {
+                var userModel = da.Users.GetById(user.UserID);
+                if (userModel == null)
+                {
+                    throw new Exception("Unable to find user");
+                }
+                return ApiResponse.Json(HttpStatusCode.OK, userModel);
+            }
+        }
+
+
+        //Get the attributes of a specific user
+        [HttpGet("{id}")]
+        public IActionResult Get(string id)
+        {
+            if (id == "current") return current();
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+            using (var da = api.DAFactory.Get())
+            {
+                var userModel = da.Users.GetById(uint.Parse(id));
+                if (userModel == null) { throw new Exception("Unable to find user"); }
+                return ApiResponse.Json(HttpStatusCode.OK, userModel);
+            }
+        }
+
+        /// <summary>
+        /// Unbans a user by IP and user.
+        /// </summary>
+        /// <param name="user_id">ID of user to unban.</param>
+        /// <returns></returns>
+        [HttpPost]
+        [Route("admin/unban")]
+        public IActionResult UnbanUser([FromBody] string user_id)
+        {
+            Api api = Api.INSTANCE;
+
+            api.DemandModerator(Request);
+
+            using (var da = api.DAFactory.Get())
+            {
+                User userModel = da.Users.GetById(uint.Parse(user_id));
+
+                if(userModel.is_banned)
+                {
+                    da.Users.UpdateBanned(uint.Parse(user_id), false);
+                }
+
+                var ban = da.Bans.GetByIP(userModel.last_ip);
+
+                if (ban!=null)
+                {
+                    da.Bans.Remove(userModel.user_id);
+                }
+
+                return ApiResponse.Json(HttpStatusCode.OK, new
+                {
+                    status = "success"
+                });
+            }
+        }
+
+        /// <summary>
+        /// Sends an in-game email message to a player.
+        /// </summary>
+        /// <param name="mail"></param>
+        /// <returns></returns>
+        [HttpPost]
+        [Route("admin/mail")]
+        public IActionResult SendMail(MailCreateModel mail)
+        {
+            Api api = Api.INSTANCE;
+
+            api.DemandAdmin(Request);
+
+            using (var da = api.DAFactory.Get())
+            {
+                User recipient = da.Users.GetById(uint.Parse(mail.target_id));
+
+                if (recipient == null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new 
+                    {
+                        status = "invalid_target_id"
+                    });
+                }
+
+                if (mail.subject.Trim() == "")
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new 
+                    {
+                        status = "subject_empty"
+                    });
+                }
+
+                if (mail.body.Trim() == "")
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new 
+                    {
+                        status = "body_empty"
+                    });
+                }
+
+                // Save mail in db
+                int message_id = da.Inbox.CreateMessage(new DbInboxMsg
+                {
+                    sender_id = 2147483648,
+                    target_id = uint.Parse(mail.target_id),
+                    subject = mail.subject,
+                    body = mail.body,
+                    sender_name = "FreeSO Staff",
+                    time = DateTime.UtcNow,
+                    msg_type = 4,
+                    msg_subtype = 0,
+                    read_state = 0,
+                });
+
+                // Try and notify the user ingame
+                api.RequestMailNotify(message_id, mail.subject, mail.body, uint.Parse(mail.target_id));
+
+                return ApiResponse.Json(HttpStatusCode.OK, new
+                {
+                    status = "success"
+                });
+            }
+        }
+
+        /// <summary>
+        /// Kicks a user out the current session.
+        /// </summary>
+        /// <param name="kick"></param>
+        /// <returns></returns>
+        [HttpPost]
+        [Route("admin/kick")]
+        public IActionResult KickUser([FromBody] string user_id)
+        {
+            Api api = Api.INSTANCE;
+
+            api.DemandModerator(Request);
+
+            api.RequestUserDisconnect(uint.Parse(user_id));
+
+            return ApiResponse.Json(HttpStatusCode.OK, new {
+                status = "success"
+            });
+        }
+
+        /// <summary>
+        /// Bans a user and kicks them.
+        /// </summary>
+        /// <param name="ban"></param>
+        /// <returns></returns>
+        [HttpPost]
+        [Route("admin/ban")]
+        public IActionResult BanUser(BanCreateModel ban)
+        {
+            Api api = Api.INSTANCE;
+
+            api.DemandModerator(Request);
+
+            using (var da = api.DAFactory.Get())
+            {
+                User userModel = da.Users.GetById(uint.Parse(ban.user_id));
+
+                if (userModel == null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new
+                    {
+                        status = "invalid_id"
+                    });
+                }
+
+                if (ban.ban_type == "ip")
+                {
+                    if (da.Bans.GetByIP(userModel.last_ip) != null)
+                    {
+                        return ApiResponse.Json(HttpStatusCode.OK, new
+                        {
+                            status = "already_banned"
+                        });
+                    }
+
+                    if (userModel.last_ip == "127.0.0.1")
+                    {
+                        return ApiResponse.Json(HttpStatusCode.OK, new
+                        {
+                            status = "invalid_ip"
+                        });
+                    }
+
+                    da.Bans.Add(userModel.last_ip, userModel.user_id, ban.reason, int.Parse(ban.end_date), userModel.client_id);
+
+                    api.RequestUserDisconnect(userModel.user_id);
+
+                    api.SendBanMail(userModel.username, userModel.email, uint.Parse(ban.end_date));
+
+                    return ApiResponse.Json(HttpStatusCode.OK, new
+                    {
+                        status = "success"
+                    });
+                }
+                else if (ban.ban_type == "user")
+                {
+                    if (userModel.is_banned)
+                    {
+                        return ApiResponse.Json(HttpStatusCode.NotFound, new
+                        {
+                            status = "already_banned"
+                        });
+                    }
+
+                    da.Users.UpdateBanned(userModel.user_id, true);
+
+                    api.RequestUserDisconnect(userModel.user_id);
+
+                    api.SendBanMail(userModel.username, userModel.email, uint.Parse(ban.end_date));
+
+                    return ApiResponse.Json(HttpStatusCode.OK, new
+                    {
+                        status = "success"
+                    });
+                }
+
+                return ApiResponse.Json(HttpStatusCode.OK, new
+                {
+                    status = "invalid_ban_type"
+                });
+            }
+        }
+
+        //List users
+        [HttpGet]
+        public IActionResult Get(int limit, int offset, string order)
+        {
+            if (limit == 0) limit = 20;
+            if (order == null) order = "register_date";
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+            using (var da = api.DAFactory.Get())
+            {
+
+                if (limit > 100)
+                {
+                    limit = 100;
+                }
+
+                var result = da.Users.All((int)offset, (int)limit);
+                return ApiResponse.PagedList<User>(Request, HttpStatusCode.OK, result);
+            }
+        }
+
+        //Create a new user
+        [HttpPost]
+        public IActionResult Post(UserCreateModel user)
+        {
+            var api = Api.INSTANCE;
+            var nuser = api.RequireAuthentication(Request);
+            api.DemandModerator(nuser);
+
+            if (user.is_admin)
+            {
+                //I need admin claim to do this
+                api.DemandAdmin(nuser);
+            }
+
+            using (var da = api.DAFactory.Get())
+            {
+                var userModel = new User();
+                userModel.username = user.username;
+                userModel.email = user.email;
+                userModel.is_admin = user.is_admin;
+                userModel.is_moderator = user.is_moderator;
+                userModel.user_state = UserState.valid;
+                userModel.register_date = Epoch.Now;
+                userModel.is_banned = false;
+
+                var userId = da.Users.Create(userModel);
+
+                userModel = da.Users.GetById(userId);
+                if (userModel == null) { throw new Exception("Unable to find user"); }
+                return ApiResponse.Json(HttpStatusCode.OK, userModel);
+            }
+        }
+    }
+
+    public class UserCreateModel
+    {
+        public string username { get; set; }
+        public string email { get; set; }
+        public string password { get; set; }
+        public bool is_admin { get; set; }
+        public bool is_moderator { get; set; }
+    }
+
+    public class BanCreateModel
+    {
+        public string ban_type { get; set; }
+        public string user_id { get; set; }
+        public string reason { get; set; }
+        public string end_date { get; set; }
+    }
+
+    public class MailCreateModel
+    {
+        public string target_id { get; set; }
+        public string subject { get; set; }
+        public string body { get; set; }
+        public string sender_name { get; set; }
+    }
+}

server/FSO.Server.Api.Core/Controllers/AuthLoginController.cs

@@ -0,0 +1,134 @@
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Common;
+using FSO.Server.Database.DA.AuthTickets;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Net;
+using System.Text;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [Route("AuthLogin")]
+    [ApiController]
+    public class AuthLoginController : ControllerBase
+    {
+        private static Func<IActionResult> ERROR_020 = printError("INV-020", "Please enter your member name and password.");
+        private static Func<IActionResult> ERROR_110 = printError("INV-110", "The member name or password you have entered is incorrect. Please try again.");
+        private static Func<IActionResult> ERROR_302 = printError("INV-302", "The game has experienced an internal error. Please try again.");
+        private static Func<IActionResult> ERROR_160 = printError("INV-160", "The server is currently down for maintainance. Please try again later.");
+        private static Func<IActionResult> ERROR_150 = printError("INV-150", "We're sorry, but your account has been suspended or cancelled.");
+        private static string LOCK_MESSAGE = "Your account has been locked due to too many incorrect login attempts. " +
+            "If you cannot remember your password, it can be reset at https://beta.freeso.org/forgot. Locked for: ";
+
+        public static int LockAttempts = 5;
+
+        public static int[] LockDuration = new int[] {
+            5,
+            15,
+            30,
+            60,
+            120,
+            720,
+            1440
+        };
+
+        // GET api/<controller>
+        [HttpGet]
+        public IActionResult Get(string username, string password, string version, string clientid)
+        {
+            if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
+            {
+                return ERROR_020();
+            }
+
+            AuthTicket ticket = null;
+
+            var api = Api.INSTANCE;
+
+            using (var db = api.DAFactory.Get())
+            {
+                var user = db.Users.GetByUsername(username);
+                if (user == null)
+                {
+                    return ERROR_110();
+                }
+
+                if (user.is_banned)
+                {
+                    return ERROR_150();
+                }
+
+                if (api.Config.Maintainance && !(user.is_admin || user.is_moderator))
+                {
+                    return ERROR_160();
+                }
+
+                var ip = ApiUtils.GetIP(Request);
+
+                var accLock = db.Users.GetRemainingAuth(user.user_id, ip);
+                if (accLock != null && (accLock.active || accLock.count >= LockAttempts) && accLock.expire_time > Epoch.Now)
+                {
+                    return printError("INV-170", LOCK_MESSAGE + Epoch.HMSRemaining(accLock.expire_time))();
+                }
+
+                var authSettings = db.Users.GetAuthenticationSettings(user.user_id);
+                var isPasswordCorrect = PasswordHasher.Verify(password, new PasswordHash
+                {
+                    data = authSettings.data,
+                    scheme = authSettings.scheme_class
+                });
+
+                if (!isPasswordCorrect)
+                {
+                    var failDelay = 60 * LockDuration[Math.Min(LockDuration.Length - 1, db.Users.FailedConsecutive(user.user_id, ip))];
+                    if (accLock == null)
+                    {
+                        db.Users.NewFailedAuth(user.user_id, ip, (uint)failDelay);
+                    } else
+                    {
+                        var remaining = db.Users.FailedAuth(accLock.attempt_id, (uint)failDelay, LockAttempts);
+                        if (remaining == 0)
+                            return printError("INV-170", LOCK_MESSAGE + Epoch.HMSRemaining(Epoch.Now + (uint)failDelay))();
+                    }
+                    return ERROR_110();
+                }
+                
+                var ban = db.Bans.GetByIP(ip);
+                if (ban != null)
+                {
+                    return ERROR_110();
+                }
+
+                db.Users.SuccessfulAuth(user.user_id, ip);
+                db.Users.UpdateClientID(user.user_id, clientid ?? "0");
+
+                /** Make a ticket **/
+                ticket = new AuthTicket();
+                ticket.ticket_id = Guid.NewGuid().ToString().Replace("-", "");
+                ticket.user_id = user.user_id;
+                ticket.date = Epoch.Now;
+                ticket.ip = ip;
+
+                db.AuthTickets.Create(ticket);
+                db.Users.UpdateLastLogin(user.user_id, Epoch.Now);
+            }
+            var content = "Valid=TRUE\r\nTicket=" + ticket.ticket_id.ToString() + "\r\n";
+            return ApiResponse.Plain(HttpStatusCode.OK, content);
+        }
+
+
+        public static Func<IActionResult> printError(String code, String message)
+        {
+            StringBuilder result = new StringBuilder();
+            result.AppendLine("Valid=FALSE");
+            result.AppendLine("Ticket=0");
+            result.AppendLine("reasontext=" + code + ";" + message);
+            result.AppendLine("reasonurl=");
+
+            return () =>
+            {
+                return ApiResponse.Plain(HttpStatusCode.OK, result.ToString());
+            };
+        }
+    }
+}

server/FSO.Server.Api.Core/Controllers/AvatarDataController.cs

@@ -0,0 +1,48 @@
+using FSO.Common.Utils;
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Protocol.CitySelector;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Net;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [EnableCors]
+    [Route("cityselector/app/AvatarDataServlet")]
+    [ApiController]
+    public class AvatarDataController : ControllerBase
+    {
+        public IActionResult Get()
+        {
+            var api = Api.INSTANCE;
+            var user = api.RequireAuthentication(Request);
+            
+            var result = new XMLList<AvatarData>("The-Sims-Online");
+
+            using (var db = api.DAFactory.Get())
+            {
+                var avatars = db.Avatars.GetSummaryByUserId(user.UserID);
+
+                foreach (var avatar in avatars)
+                {
+                    result.Add(new AvatarData
+                    {
+                        ID = avatar.avatar_id,
+                        Name = avatar.name,
+                        ShardName = api.Shards.GetById(avatar.shard_id).Name,
+                        HeadOutfitID = avatar.head,
+                        BodyOutfitID = avatar.body,
+                        AppearanceType = (AvatarAppearanceType)Enum.Parse(typeof(AvatarAppearanceType), avatar.skin_tone.ToString()),
+                        Description = avatar.description,
+                        LotId = avatar.lot_id,
+                        LotName = avatar.lot_name,
+                        LotLocation = avatar.lot_location
+                    });
+                }
+            }
+
+            return ApiResponse.Xml(HttpStatusCode.OK, result);
+        }
+    }
+}

server/FSO.Server.Api.Core/Controllers/AvatarInfoController.cs

@@ -0,0 +1,321 @@
+using FSO.Server.Api.Core.Utils;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using FSO.Server.Database.DA.Avatars;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [EnableCors]
+    [ApiController]
+    public class AvatarInfoController : ControllerBase
+    {
+        //get the avatars by user_id
+        [Route("userapi/user/avatars")]
+        public IActionResult GetByUser()
+        {
+            var api = Api.INSTANCE;
+            var user = api.RequireAuthentication(Request);
+            if (!user.Claims.Contains("userReadPermissions")) return ApiResponse.Json(HttpStatusCode.OK, new JSONAvatarError("No read premissions found."));
+
+            using (var da = api.DAFactory.Get())
+            {
+                var avatars = da.Avatars.GetByUserId(user.UserID);
+                List<JSONAvatar> avatarJson = new List<JSONAvatar>();
+                foreach (var avatar in avatars)
+                {
+                    avatarJson.Add(new JSONAvatar
+                    {
+                        avatar_id = avatar.avatar_id,
+                        shard_id = avatar.shard_id,
+                        name = avatar.name,
+                        gender = avatar.gender,
+                        date = avatar.date,
+                        description = avatar.description,
+                        current_job = avatar.current_job,
+                        mayor_nhood = avatar.mayor_nhood
+                    });
+                }
+                var avatarsJson = new JSONAvatars();
+                avatarsJson.avatars = avatarJson;
+                return ApiResponse.Json(HttpStatusCode.OK, avatarsJson);
+            }
+        }
+        //get the avatar by id
+        [HttpGet]
+        [Route("userapi/avatars/{avartarId}")]
+        public IActionResult GetByID(uint avartarId)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var avatar = da.Avatars.Get(avartarId);
+                if (avatar == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONAvatarError("Avatar not found"));
+
+                var avatarJson = new JSONAvatar
+                {
+                    avatar_id = avatar.avatar_id,
+                    shard_id = avatar.shard_id,
+                    name = avatar.name,
+                    gender = avatar.gender,
+                    date = avatar.date,
+                    description = avatar.description,
+                    current_job = avatar.current_job,
+                    mayor_nhood = avatar.mayor_nhood
+
+                };
+
+                return ApiResponse.Json(HttpStatusCode.OK, avatarJson);
+            }
+        }
+        //get the avatars by ids
+        [Route("userapi/avatars")]
+        public IActionResult GetByIDs([FromQuery(Name = "ids")]string idsString)
+        {
+            var api = Api.INSTANCE;
+            try
+            {
+                uint[] ids = Array.ConvertAll(idsString.Split(","), uint.Parse);
+                using (var da = api.DAFactory.Get())
+                {
+                    var avatars = da.Avatars.GetMultiple(ids);
+                    List<JSONAvatar> avatarJson = new List<JSONAvatar>();
+                    foreach (var avatar in avatars)
+                    {
+                        avatarJson.Add(new JSONAvatar
+                        {
+                            avatar_id = avatar.avatar_id,
+                            shard_id = avatar.shard_id,
+                            name = avatar.name,
+                            gender = avatar.gender,
+                            date = avatar.date,
+                            description = avatar.description,
+                            current_job = avatar.current_job,
+                            mayor_nhood = avatar.mayor_nhood
+                        });
+                    }
+                    var avatarsJson = new JSONAvatars();
+                    avatarsJson.avatars = avatarJson;
+                    return ApiResponse.Json(HttpStatusCode.OK, avatarsJson);
+                }
+            }
+            catch
+            {
+                return ApiResponse.Json(HttpStatusCode.NotFound, new JSONAvatarError("Error during cast. (invalid_value)"));
+            }
+        }
+        //gets all the avatars from one city
+        [HttpGet]
+        [Route("userapi/city/{shardId}/avatars/page/{pageNum}")]
+        public IActionResult GetAll(int shardId,int pageNum, [FromQuery(Name = "avatars_on_page")]int perPage)
+        {
+            var api = Api.INSTANCE;
+            if(perPage == 0)
+            {
+                perPage = 100;
+            }
+            if (perPage > 500) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("The max amount of avatars per page is 500"));
+            using (var da = api.DAFactory.Get())
+            {
+                pageNum = pageNum - 1;
+                
+                var avatars = da.Avatars.AllByPage(shardId, pageNum * perPage, perPage,"avatar_id");
+                var avatarCount = avatars.Total;
+                var totalPages = (avatars.Total - 1)/perPage + 1;
+
+                var pageAvatarsJson = new JSONAvatarsPage();
+                pageAvatarsJson.total_avatars = avatarCount;
+                pageAvatarsJson.page = pageNum + 1;
+                pageAvatarsJson.total_pages = (int)totalPages;
+                pageAvatarsJson.avatars_on_page = avatars.Count();
+
+                if (pageNum < 0 || pageNum >= (int)totalPages) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONAvatarError("Page not found"));
+                if (avatars == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONAvatarError("Avatar not found"));
+
+                List<JSONAvatar> avatarJson = new List<JSONAvatar>();
+                foreach (var avatar in avatars)
+                {
+                    avatarJson.Add(new JSONAvatar
+                    {
+                        avatar_id = avatar.avatar_id,
+                        shard_id = avatar.shard_id,
+                        name = avatar.name,
+                        gender = avatar.gender,
+                        date = avatar.date,
+                        description = avatar.description,
+                        current_job = avatar.current_job,
+                        mayor_nhood = avatar.mayor_nhood
+                    });
+
+                }
+                
+                pageAvatarsJson.avatars = avatarJson;
+                return ApiResponse.Json(HttpStatusCode.OK, pageAvatarsJson);
+            }
+        }
+        //gets avatar by name
+        [HttpGet]
+        [Route("userapi/city/{shardId}/avatars/name/{name}")]
+        public IActionResult GetByName(int shardId, string name)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var avatar = da.Avatars.SearchExact(shardId, name, 1).FirstOrDefault();
+                if (avatar == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONAvatarError("Avatar not found"));
+
+                var avatarJson = new JSONAvatar();
+                var avatarById = da.Avatars.Get(avatar.avatar_id);
+                if (avatarById == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONAvatarError("Avatar not found"));
+                avatarJson = (new JSONAvatar
+                {
+                    avatar_id = avatarById.avatar_id,
+                    shard_id = avatarById.shard_id,
+                    name = avatarById.name,
+                    gender = avatarById.gender,
+                    date = avatarById.date,
+                    description = avatarById.description,
+                    current_job = avatarById.current_job,
+                    mayor_nhood = avatarById.mayor_nhood
+                });
+                return ApiResponse.Json(HttpStatusCode.OK, avatarJson);
+            }
+        }
+        //gets all the avatars that live in a specific neighbourhood
+        [HttpGet]
+        [Route("userapi/city/{shardId}/avatars/neighborhood/{nhoodId}")]
+        public IActionResult GetByNhood(int shardId, uint nhoodId)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lots = da.Lots.All(shardId).Where(x => x.neighborhood_id == nhoodId);
+                if (lots == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONAvatarError("Lots not found"));
+
+                List<JSONAvatar> avatarJson = new List<JSONAvatar>();
+                foreach (var lot in lots)
+                {
+                    if(lot.category != FSO.Common.Enum.LotCategory.community)
+                    {
+                        var roomies = da.Roommates.GetLotRoommates(lot.lot_id).Where(x => x.is_pending == 0).Select(x => x.avatar_id);
+                        var avatars = da.Avatars.GetMultiple(roomies.ToArray());
+                        foreach (var avatar in avatars)
+                        {
+                            avatarJson.Add(new JSONAvatar
+                            {
+                                avatar_id = avatar.avatar_id,
+                                shard_id = avatar.shard_id,
+                                name = avatar.name,
+                                gender = avatar.gender,
+                                date = avatar.date,
+                                description = avatar.description,
+                                current_job = avatar.current_job,
+                                mayor_nhood = avatar.mayor_nhood
+                            });
+                        }
+                    }
+                    
+                }
+                var avatarsJson = new JSONAvatars();
+                avatarsJson.avatars = avatarJson;
+                return ApiResponse.Json(HttpStatusCode.OK, avatarsJson);
+            }
+        }
+        //get all online Avatars
+        [HttpGet]
+        [Route("userapi/avatars/online")]
+        public IActionResult GetOnline([FromQuery(Name = "compact")]bool compact)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                List<JSONAvatarSmall> avatarSmallJson = new List<JSONAvatarSmall>();
+                var avatarJson = new JSONAvatarOnline();
+                if (compact)
+                {
+                    var avatarStatus = da.AvatarClaims.GetAllActiveAvatarsCount();
+                    if (avatarStatus == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONAvatarError("ammount not found"));
+                    avatarJson.avatars_online_count = avatarStatus;
+                }
+                
+                
+                if (!compact)
+                {
+                    var avatarStatus = da.AvatarClaims.GetAllActiveAvatars();
+                    if (avatarStatus == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONAvatarError("Avatars not found"));
+
+                    foreach (var avatar in avatarStatus)
+                    {
+                        uint location = 0;
+                        if (avatar.privacy_mode == 0)
+                        {
+                            location = avatar.location;
+                        }
+                        avatarSmallJson.Add(new JSONAvatarSmall
+                        {
+                            avatar_id = avatar.avatar_id,
+                            name = avatar.name,
+                            privacy_mode = avatar.privacy_mode,
+                            location = location
+                        });
+
+                    }
+                    avatarJson.avatars_online_count = avatarStatus.Count();
+                }
+                
+                avatarJson.avatars = avatarSmallJson;
+                return ApiResponse.Json(HttpStatusCode.OK, avatarJson);
+            }
+        }
+    }
+    public class JSONAvatarError
+    {
+        public string error;
+        public JSONAvatarError(string errorString)
+        {
+            error = errorString;
+        }
+    }
+    public class JSONAvatarsPage
+    {
+        public int page { get; set; }
+        public int total_pages { get; set; }
+        public int total_avatars { get; set; }
+        public int avatars_on_page { get; set; }
+        public List<JSONAvatar> avatars { get; set; }
+    }
+    public class JSONAvatarOnline
+    {
+        public int? avatars_online_count { get; set; }
+        public List<JSONAvatarSmall> avatars { get; set; }
+    }
+    public class JSONAvatarSmall
+    {
+        public uint avatar_id { get; set; }
+        public string name { get; set; }
+        public byte privacy_mode { get; set; }
+        public uint location { get; set; }
+    }
+    public class JSONAvatars
+    {
+        public List<JSONAvatar> avatars { get; set; }
+    }
+    public class JSONAvatar
+    {
+        public uint avatar_id { get; set; }
+        public int shard_id { get; set; }
+        public string name { get; set; }
+        public DbAvatarGender gender { get; set; }
+        public uint date { get; set; }
+        public string description { get; set; }
+        public ushort current_job { get; set; }
+        public int? mayor_nhood { get; set; }
+    }
+}

server/FSO.Server.Api.Core/Controllers/BulletinInfoController.cs

@@ -0,0 +1,134 @@
+using FSO.Server.Api.Core.Utils;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using FSO.Server.Database.DA.Bulletin;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [EnableCors]
+    [ApiController]
+    public class BulletinInfoController : ControllerBase
+    {
+        [HttpGet("nhoodId")]
+        [Route("userapi/neighborhood/{nhoodId}/bulletins")]
+        public IActionResult GetByNhoodAndAfter(uint nhoodId, [FromQuery(Name = "after")]uint after)
+        {
+            var api = Api.INSTANCE;
+            
+            using (var da = api.DAFactory.Get())
+            {
+                if (after == null) after = 0;
+                var bulletins = da.BulletinPosts.GetByNhoodId(nhoodId, after);
+                if (bulletins == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONBulletinError("Bulletins not found"));
+
+                List<JSONBulletin> bulletinJson = new List<JSONBulletin>();
+                foreach (var bulletin in bulletins)
+                {
+                    bulletinJson.Add(new JSONBulletin
+                    {
+                        bulletin_id = bulletin.bulletin_id,
+                        neighborhood_id = bulletin.neighborhood_id,
+                        avatar_id = bulletin.avatar_id,
+                        title = bulletin.title,
+                        body = bulletin.body,
+                        date = bulletin.date,
+                        flags = bulletin.flags,
+                        lot_id = bulletin.lot_id,
+                        type = bulletin.type
+                    });
+
+                }
+                var bulletinsJson = new JSONBulletins();
+                bulletinsJson.bulletins = bulletinJson;
+                return ApiResponse.Json(HttpStatusCode.OK, bulletinsJson);
+            }
+        }
+        [HttpGet]
+        [Route("userapi/neighborhood/{nhoodid}/bulletins/{bulletinId}")]
+        public IActionResult GetByID(uint bulletinId)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var bulletin = da.BulletinPosts.Get(bulletinId);
+                if (bulletin == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONBulletinError("Bulletin not found"));
+
+                var bulletinJson = new JSONBulletin();
+                bulletinJson = new JSONBulletin
+                {
+                    bulletin_id = bulletin.bulletin_id,
+                    neighborhood_id = bulletin.neighborhood_id,
+                    avatar_id = bulletin.avatar_id,
+                    title = bulletin.title,
+                    body = bulletin.body,
+                    date = bulletin.date,
+                    flags = bulletin.flags,
+                    lot_id = bulletin.lot_id,
+                    type = bulletin.type
+                };
+                return ApiResponse.Json(HttpStatusCode.OK, bulletinJson);
+            }
+        }
+        [HttpGet]
+        [Route("userapi/neighborhood/{nhoodId}/bulletins/type/{bulletinType}")]
+        public IActionResult GetByNhoodAndType(uint nhoodId,DbBulletinType bulletinType)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var bulletins = da.BulletinPosts.GetByNhoodId(nhoodId, 0).Where(x => x.type == bulletinType);
+                if (bulletins == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONBulletinError("Bulletins not found"));
+
+                List<JSONBulletin> bulletinJson = new List<JSONBulletin>();
+                foreach (var bulletin in bulletins)
+                {
+                    bulletinJson.Add(new JSONBulletin
+                    {
+                        bulletin_id = bulletin.bulletin_id,
+                        neighborhood_id = bulletin.neighborhood_id,
+                        avatar_id = bulletin.avatar_id,
+                        title = bulletin.title,
+                        body = bulletin.body,
+                        date = bulletin.date,
+                        flags = bulletin.flags,
+                        lot_id = bulletin.lot_id,
+                        type = bulletin.type
+                    });
+
+                }
+                var bulletinsJson = new JSONBulletins();
+                bulletinsJson.bulletins = bulletinJson;
+                return ApiResponse.Json(HttpStatusCode.OK, bulletinsJson);
+            }
+        }
+    }
+    public class JSONBulletinError
+    {
+        public string error;
+        public JSONBulletinError(string errorString)
+        {
+            error = errorString;
+        }
+    }
+    public class JSONBulletins
+    {
+        public List<JSONBulletin> bulletins { get; set; }
+    }
+    public class JSONBulletin
+    {
+        public uint bulletin_id { get; set; }
+        public int neighborhood_id { get; set; }
+        public uint? avatar_id { get; set; }
+        public string title { get; set; }
+        public string body { get; set; }
+        public uint date { get; set; }
+        public uint flags { get; set; }
+        public int? lot_id { get; set; }
+        public DbBulletinType type { get; set; }
+    }
+}

server/FSO.Server.Api.Core/Controllers/CityJSONController.cs

@@ -0,0 +1,73 @@
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Common;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using System.Net;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [EnableCors]
+    [ApiController]
+    public class CityJSONController : ControllerBase
+    {
+        private static object ModelLock = new object { };
+        private static CityInfoModel LastModel = new CityInfoModel();
+        private static uint LastModelUpdate;
+
+        [HttpGet]
+        [Route("userapi/city/{shardid}/city.json")]
+        public IActionResult Get(int shardid)
+        {
+            var api = Api.INSTANCE;
+
+            var now = Epoch.Now;
+            if (LastModelUpdate < now - 15)
+            {
+                LastModelUpdate = now;
+                lock (ModelLock)
+                {
+                    LastModel = new CityInfoModel();
+                    using (var da = api.DAFactory.Get())
+                    {
+                        var lots = da.Lots.AllLocations(shardid);
+                        var lotstatus = da.LotClaims.AllLocations(shardid);
+                        LastModel.reservedLots = lots.ConvertAll(x => x.location).ToArray();
+                        LastModel.names = lots.ConvertAll(x => x.name).ToArray();
+                        LastModel.activeLots = lotstatus.ConvertAll(x => x.location).ToArray();
+                        LastModel.onlineCount = lotstatus.ConvertAll(x => x.active).ToArray();
+                    }
+                }
+            }
+            lock (ModelLock)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, LastModel);
+            }
+        }
+
+        [HttpGet]
+        [Route("userapi/city/thumbwork.json")]
+        public IActionResult ThumbWork()
+        {
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+
+            using (var da = api.DAFactory.Get())
+            {
+                var work = da.Lots.Get3DWork();
+                if (work == null) return ApiResponse.Plain(HttpStatusCode.OK, "");
+                else
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, work);
+                }
+            }
+        }
+    }
+
+    class CityInfoModel
+    {
+        public string[] names;
+        public uint[] reservedLots;
+        public uint[] activeLots;
+        public int[] onlineCount;
+    }
+}

server/FSO.Server.Api.Core/Controllers/ElectionInfoController.cs

@@ -0,0 +1,79 @@
+using FSO.Server.Api.Core.Utils;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using System.Collections.Generic;
+using System.Net;
+using FSO.Server.Database.DA.Elections;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [EnableCors]
+    [ApiController]
+    public class ElectionController : ControllerBase
+    {
+        [HttpGet]
+        [Route("userapi/neighborhood/{nhoodId}/elections")]
+        public IActionResult GetByNhood(uint nhoodId)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var nhood = da.Neighborhoods.Get(nhoodId);
+                if (nhood.election_cycle_id == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONElectionError("Election cycle not found"));
+
+                var electionCycle = da.Elections.GetCycle((uint)nhood.election_cycle_id);
+                
+                var electionCandidates = new List<DbElectionCandidate>();
+                if (electionCycle.current_state == Database.DA.Elections.DbElectionCycleState.election)
+                    electionCandidates = da.Elections.GetCandidates(electionCycle.cycle_id, Database.DA.Elections.DbCandidateState.running);
+
+                if (electionCycle.current_state == Database.DA.Elections.DbElectionCycleState.ended)
+                    electionCandidates = da.Elections.GetCandidates(electionCycle.cycle_id, Database.DA.Elections.DbCandidateState.won);
+
+                if (electionCycle == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONElectionError("Election cycle not found"));
+
+                List<JSONCandidates> candidatesJson = new List<JSONCandidates>();
+                foreach (var candidate in electionCandidates)
+                {
+                    candidatesJson.Add(new JSONCandidates
+                    {
+                       candidate_avatar_id = candidate.candidate_avatar_id,
+                       comment = candidate.comment,
+                       state = candidate.state
+                    });
+
+                }
+                var electionJson = new JSONElections();
+                electionJson.candidates = candidatesJson;
+                electionJson.current_state = electionCycle.current_state;
+                electionJson.neighborhood_id = nhood.neighborhood_id;
+                electionJson.start_date = electionCycle.start_date;
+                electionJson.end_date = electionCycle.end_date;
+                return ApiResponse.Json(HttpStatusCode.OK, electionJson);
+            }
+        }
+    }
+    public class JSONElectionError
+    {
+        public string error;
+        public JSONElectionError(string errorString)
+        {
+            error = errorString;
+        }
+    }
+    public class JSONElections
+    {
+        public DbElectionCycleState current_state { get; set; }
+        public int neighborhood_id { get; set; }
+        public uint start_date { get; set; }
+        public uint end_date { get; set; }
+        public List<JSONCandidates> candidates { get; set; }
+    }
+    public class JSONCandidates
+    {
+        public uint candidate_avatar_id { get; set; }
+        public string comment { get; set; }
+        public DbCandidateState state { get; set; }
+    }
+}

server/FSO.Server.Api.Core/Controllers/GameAPI/UpdateController.cs

@@ -0,0 +1,38 @@
+using System.Linq;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+
+namespace FSO.Server.Api.Core.Controllers.GameAPI
+{
+    [EnableCors]
+    [Route("userapi/update")]
+    public class UpdateController : ControllerBase
+    {
+
+        // GET userapi/update
+        // get recent PUBLISHED updates for the active branch, ordered by publish date
+        [HttpGet()]
+        public IActionResult Get(int id)
+        {
+            var api = Api.INSTANCE;
+            using (var da = api.DAFactory.Get())
+            {
+                var recents = da.Updates.GetRecentUpdatesForBranchByName(api.Config.BranchName, 20);
+                return new JsonResult(recents.ToList());
+            }
+        }
+
+        // GET: userapi/update/<branch>
+        // get recent PUBLISHED updates for a specific branch, ordered by publish date
+        [HttpGet("{branch}")]
+        public IActionResult Get(string branch)
+        {
+            var api = Api.INSTANCE;
+            using (var da = api.DAFactory.Get())
+            {
+                var recents = da.Updates.GetRecentUpdatesForBranchByName(branch, 20);
+                return new JsonResult(recents.ToList());
+            }
+        }
+    }
+}

server/FSO.Server.Api.Core/Controllers/GithubController.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Security.Cryptography;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using Octokit;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [EnableCors]
+    [ApiController]
+    public class GithubController : ControllerBase
+    {
+        readonly GitHubClient client =
+            new GitHubClient(new ProductHeaderValue(Api.INSTANCE.Github.AppName), new Uri("https://github.com/"));
+
+        private string StoredToken;
+        private static string CSRF;
+
+        // GET: /<controller>/
+        [HttpGet]
+        [Route("github/")]
+        public IActionResult Index()
+        {
+            if (Api.INSTANCE.Github == null) return NotFound();
+            if (Api.INSTANCE.Github.AccessToken != null) return NotFound();
+
+            return Redirect(GetOauthLoginUrl());
+        }
+
+        [HttpGet]
+        [Route("github/callback")]
+        public async Task<IActionResult> Callback(string code, string state)
+        {
+            if (Api.INSTANCE.Github == null) return NotFound();
+            if (Api.INSTANCE.Github.AccessToken != null) return NotFound();
+
+            if (!String.IsNullOrEmpty(code))
+            {
+                var expectedState = CSRF;
+                if (state != expectedState) throw new InvalidOperationException("SECURITY FAIL!");
+                //CSRF = null;
+
+                var token = await client.Oauth.CreateAccessToken(
+                    new OauthTokenRequest(Api.INSTANCE.Github.ClientID, Api.INSTANCE.Github.ClientSecret, code)
+                    {
+                        RedirectUri = new Uri("http://localhost:80/github/callback")
+                    });
+                StoredToken = token.AccessToken;
+            }
+
+            return Ok(StoredToken);
+        }
+
+        private string GetOauthLoginUrl()
+        {
+            var rngCsp = new RNGCryptoServiceProvider();
+            string csrf = "";
+            var random = new byte[24];
+            rngCsp.GetBytes(random);
+            for (int i=0; i<24; i++)
+            {
+                csrf += (char)('?' + random[i]/4);
+            }
+            CSRF = csrf;
+
+            // 1. Redirect users to request GitHub access
+            var request = new OauthLoginRequest(Api.INSTANCE.Github.ClientID)
+            {
+                Scopes = { "admin:org", "repo" },
+                State = csrf
+            };
+            var oauthLoginUrl = client.Oauth.GetGitHubLoginUrl(request);
+            return oauthLoginUrl.ToString();
+        }
+    }
+}

server/FSO.Server.Api.Core/Controllers/InitialConnectController.cs

@@ -0,0 +1,93 @@
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Common;
+using FSO.Server.Protocol.CitySelector;
+using FSO.Server.Servers.Api.JsonWebToken;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Net;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [Route("cityselector/app/InitialConnectServlet")]
+    [ApiController]
+    public class InitialConnectController : ControllerBase
+    {
+        private static Func<IActionResult> ERROR_MISSING_TOKEN = ApiResponse.XmlFuture(HttpStatusCode.OK, new XMLErrorMessage("501", "Token not found"));
+        private static Func<IActionResult> ERROR_EXPIRED_TOKEN = ApiResponse.XmlFuture(HttpStatusCode.OK, new XMLErrorMessage("502", "Token has expired"));
+
+        [HttpGet]
+        public IActionResult Get(string ticket, string version)
+        {
+            var api = Api.INSTANCE;
+
+            if (ticket == null || ticket == "" || version == null){
+                return ERROR_MISSING_TOKEN();
+            }
+
+            using (var db = api.DAFactory.Get())
+            {
+                var dbTicket = db.AuthTickets.Get(ticket);
+                if (dbTicket == null){
+                    return ERROR_MISSING_TOKEN();
+                }
+
+                db.AuthTickets.Delete((string)ticket);
+                if (dbTicket.date + api.Config.AuthTicketDuration < Epoch.Now){
+                    return ERROR_EXPIRED_TOKEN();
+                }
+
+                /** Is it a valid account? **/
+                var user = db.Users.GetById(dbTicket.user_id);
+                if (user == null){
+                    return ERROR_MISSING_TOKEN();
+                }
+
+                //Use JWT to create and sign an auth cookies
+                var session = new JWTUser()
+                {
+                    UserID = user.user_id,
+                    UserName = user.username
+                };
+
+                //TODO: This assumes 1 shard, when using multiple need to either have version download occour after
+                //avatar select, or rework the tables
+                var shardOne = api.Shards.GetById(1);
+
+                var token = api.JWT.CreateToken(session);
+
+                IActionResult response;
+                if (shardOne.UpdateID != null)
+                {
+                    var update = db.Updates.GetUpdate(shardOne.UpdateID.Value);
+                    response = ApiResponse.Xml(HttpStatusCode.OK, new UserAuthorized()
+                    {
+                        FSOBranch = shardOne.VersionName,
+                        FSOVersion = shardOne.VersionNumber,
+                        FSOUpdateUrl = update.full_zip,
+                        FSOCDNUrl = api.Config.CDNUrl
+                    });
+                }
+                else
+                {
+                    response = ApiResponse.Xml(HttpStatusCode.OK, new UserAuthorized()
+                    {
+                        FSOBranch = shardOne.VersionName,
+                        FSOVersion = shardOne.VersionNumber,
+                        FSOUpdateUrl = api.Config.UpdateUrl,
+                        FSOCDNUrl = api.Config.CDNUrl
+                    });
+                }
+                Response.Cookies.Append("fso", token.Token, new Microsoft.AspNetCore.Http.CookieOptions()
+                {
+                    Expires = DateTimeOffset.Now.AddDays(1),
+                    Domain = Request.Host.Host,
+                    Path = "/"
+                });
+                //HttpContext.Current.Response.SetCookie(new HttpCookie("fso", token.Token));
+                return response;
+            }
+        }
+
+    }
+}
+ 

server/FSO.Server.Api.Core/Controllers/LotInfoController.cs

@@ -0,0 +1,705 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using FSO.Server.Api.Core.Utils;
+using FSO.Common.Enum;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Cors;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+
+    public static class MemoryCacher
+    {
+        public static MemoryCache Default = new MemoryCache(new MemoryCacheOptions());
+        public static object GetValue(string key)
+        {
+            MemoryCache memoryCache = Default;
+            return memoryCache.Get(key);
+        }
+
+        public static bool Add(string key, object value, DateTimeOffset absExpiration)
+        {
+            MemoryCache memoryCache = Default;
+            return memoryCache.Set(key, value, absExpiration) == value;
+        }
+
+        public static void Delete(string key)
+        {
+            MemoryCache memoryCache = Default;
+            memoryCache.Remove(key);
+        }
+    }
+
+    [EnableCors]
+    [ApiController]
+    public class LotInfoController : ControllerBase
+    {
+        public static ConcurrentDictionary<int, ShardLocationCache> LotLocationCache = new ConcurrentDictionary<int, ShardLocationCache>();
+
+        public static int? IDForLocation(int shardid, uint loc)
+        {
+            var api = Api.INSTANCE;
+            var locToID = LotLocationCache.GetOrAdd(shardid, (ikey) =>
+            {
+                using (var da = api.DAFactory.Get())
+                {
+                    return new ShardLocationCache(
+                        new ConcurrentDictionary<uint, int>(da.Lots.All(ikey).Select(x => new KeyValuePair<uint, int>(x.location, x.lot_id)))
+                        );
+                }
+            });
+            if (DateTime.UtcNow - locToID.CreateTime > TimeSpan.FromMinutes(15))
+            {
+                ShardLocationCache removed;
+                LotLocationCache.TryRemove(shardid, out removed);
+            }
+
+            try
+            {
+                return locToID.Dict.GetOrAdd(loc, (ikey) =>
+                {
+                    using (var da = api.DAFactory.Get())
+                    {
+                        return da.Lots.GetByLocation(shardid, ikey).lot_id;
+                    }
+                });
+            } catch (NullReferenceException e)
+            {
+                return null;
+            }
+        }
+
+        [HttpGet]
+        [Route("userapi/city/{shardid}/{id}.png")]
+        [ResponseCache(Duration = 60 * 60, Location = ResponseCacheLocation.Any)]
+        public IActionResult Get(int shardid, uint id)
+        {
+            var dat = (byte[])MemoryCacher.GetValue("lt" + shardid + ":" + id);
+            if (dat != null)
+            {
+                return File(dat, "image/png");
+            }
+
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lot = IDForLocation(shardid, id);
+                if (lot == null) return NotFound();
+
+                FileStream stream;
+                try
+                {
+                    var ndat = System.IO.File.ReadAllBytes(Path.Combine(api.Config.NFSdir, "Lots/" + lot.Value.ToString("x8") + "/thumb.png"));
+                    MemoryCacher.Add("lt" + shardid + ":" + id, ndat, DateTime.Now.Add(new TimeSpan(1, 0, 0)));
+
+                    return File(ndat, "image/png");
+                }
+                catch (Exception e)
+                {
+                    return NotFound();
+                }
+            }
+        }
+
+        [HttpGet]
+        [Route("userapi/city/{shardid}/i{id}.json")]
+        public IActionResult GetJSON(int shardid, uint id)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lot = da.Lots.GetByLocation(shardid, id);
+                if (lot == null) return NotFound();
+
+                var roomies = da.Roommates.GetLotRoommates(lot.lot_id).Where(x => x.is_pending == 0).Select(x => x.avatar_id).ToArray();
+
+                var jlot = new JSONLot
+                {
+                    admit_mode = lot.admit_mode,
+                    category = lot.category,
+                    created_date = lot.created_date,
+                    description = lot.description,
+                    location = lot.location,
+                    name = lot.name,
+                    neighborhood_id = lot.neighborhood_id,
+                    owner_id = lot.owner_id,
+                    shard_id = lot.shard_id,
+                    skill_mode = lot.skill_mode,
+                    roommates = roomies
+                };
+
+                return ApiResponse.Json(HttpStatusCode.OK, jlot);
+            }
+        }
+
+        //New user API calls might replace old once later
+        //get lot information by location
+        [HttpGet]
+        [Route("userapi/lots/{lotId}")]
+        public IActionResult GetByID(int lotId)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lot = da.Lots.Get(lotId);
+                if (lot == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("Lot not found"));
+                var roomies = da.Roommates.GetLotRoommates(lot.lot_id).Where(x => x.is_pending == 0).Select(x => x.avatar_id).ToArray();
+
+                var lotJson = new JSONLot
+                {
+                    admit_mode = lot.admit_mode,
+                    category = lot.category,
+                    created_date = lot.created_date,
+                    description = lot.description,
+                    location = lot.location,
+                    name = lot.name,
+                    neighborhood_id = lot.neighborhood_id,
+                    owner_id = lot.owner_id,
+                    shard_id = lot.shard_id,
+                    skill_mode = lot.skill_mode,
+                    roommates = roomies,
+                    lot_id = lot.lot_id
+                };
+
+                return ApiResponse.Json(HttpStatusCode.OK, lotJson);
+            }
+        }
+        //get the lots by ids
+        [Route("userapi/lots")]
+        public IActionResult GetByIDs([FromQuery(Name = "ids")]string idsString)
+        {
+            var api = Api.INSTANCE;
+            try
+            {
+                int[] ids = Array.ConvertAll(idsString.Split(","), int.Parse);
+                using (var da = api.DAFactory.Get())
+                {
+                    var lots = da.Lots.GetMultiple(ids);
+                    if (lots == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("Lot not found"));
+
+                    List<JSONLot> lotJson = new List<JSONLot>();
+                    foreach (var lot in lots)
+                    {
+                        var roomies = da.Roommates.GetLotRoommates(lot.lot_id).Where(x => x.is_pending == 0).Select(x => x.avatar_id).ToArray();
+                        lotJson.Add(new JSONLot
+                        {
+                            admit_mode = lot.admit_mode,
+                            category = lot.category,
+                            created_date = lot.created_date,
+                            description = lot.description,
+                            location = lot.location,
+                            name = lot.name,
+                            neighborhood_id = lot.neighborhood_id,
+                            owner_id = lot.owner_id,
+                            shard_id = lot.shard_id,
+                            skill_mode = lot.skill_mode,
+                            roommates = roomies,
+                            lot_id = lot.lot_id
+                        });
+                    }
+                    var lotsJson = new JSONLots();
+                    lotsJson.lots = lotJson;
+                    return ApiResponse.Json(HttpStatusCode.OK, lotsJson);
+                }
+            }
+            catch
+            {
+                return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("Error during cast. (invalid_value)"));
+            }
+        }
+        //gets all the lots from one city
+        [HttpGet]
+        [Route("userapi/city/{shardId}/lots/page/{pageNum}")]
+        public IActionResult GetAll(int shardId, int pageNum, [FromQuery(Name = "lots_on_page")]int perPage)
+        {
+            var api = Api.INSTANCE;
+            if (perPage == 0)
+            {
+                perPage = 100;
+            }
+            if (perPage > 500) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("The max amount of lots per page is 500"));
+            using (var da = api.DAFactory.Get())
+            {
+                pageNum = pageNum - 1;
+
+                var lots = da.Lots.AllByPage(shardId, pageNum * perPage, perPage,"lot_id");
+                var lotCount = lots.Total;
+                var totalPages = (lots.Total - 1) / perPage + 1;
+                
+                var pageLotsJson = new JSONLotsPage();
+                pageLotsJson.total_lots = lotCount;
+                pageLotsJson.page = pageNum + 1;
+                pageLotsJson.total_pages = (int)totalPages;
+                pageLotsJson.lots_on_page = lots.Count();
+
+                if (pageNum < 0 || pageNum >= (int)totalPages) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("Page not found"));
+                if (lots == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("Lots not found"));
+
+                List<JSONLotSmall> lotJson = new List<JSONLotSmall>();
+                foreach (var lot in lots)
+                {
+                    lotJson.Add(new JSONLotSmall
+                    {
+                        location = lot.location,
+                        name = lot.name,
+                        description = lot.description,
+                        category = lot.category,
+                        admit_mode = lot.admit_mode,
+                        neighborhood_id = lot.neighborhood_id,
+                        lot_id = lot.lot_id
+                    });
+                }
+
+                pageLotsJson.lots = lotJson;
+                return ApiResponse.Json(HttpStatusCode.OK, pageLotsJson);
+            }
+        }
+        //get lot information by location
+        [HttpGet]
+        [Route("userapi/city/{shardId}/lots/location/{locationId}")]
+        public IActionResult GetByLocation(int shardId, uint locationId)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lot = da.Lots.GetByLocation(shardId, locationId);
+                if (lot == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("Lot not found"));
+
+                var roomies = da.Roommates.GetLotRoommates(lot.lot_id).Where(x => x.is_pending == 0).Select(x => x.avatar_id).ToArray();
+
+                var LotJSON = new JSONLot
+                {
+                    admit_mode = lot.admit_mode,
+                    category = lot.category,
+                    created_date = lot.created_date,
+                    description = lot.description,
+                    location = lot.location,
+                    name = lot.name,
+                    neighborhood_id = lot.neighborhood_id,
+                    owner_id = lot.owner_id,
+                    shard_id = lot.shard_id,
+                    skill_mode = lot.skill_mode,
+                    roommates = roomies,
+                    lot_id = lot.lot_id
+                };
+
+                return ApiResponse.Json(HttpStatusCode.OK, LotJSON);
+            }
+        }
+        //get lot information By neighbourhood
+        [HttpGet]
+        [Route("userapi/city/{shardId}/lots/neighborhood/{nhoodId}")]
+        public IActionResult GetByNhood(int shardId, uint nhoodId)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lots = da.Lots.All(shardId).Where(x => x.neighborhood_id == nhoodId);
+                if (lots == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("lots not found"));
+                List<JSONLotSmall> lotJson = new List<JSONLotSmall>();
+                foreach (var lot in lots)
+                {
+                    lotJson.Add(new JSONLotSmall
+                    {
+                        location = lot.location,
+                        name = lot.name,
+                        description = lot.description,
+                        category = lot.category,
+                        admit_mode = lot.admit_mode,
+                        neighborhood_id = lot.neighborhood_id,
+                        lot_id = lot.lot_id
+                    });
+                }
+                var lotsJson = new JSONLotsSmall();
+                lotsJson.lots = lotJson;
+                return ApiResponse.Json(HttpStatusCode.OK, lotsJson);
+            }
+        }
+        //get lot information by name
+        [HttpGet]
+        [Route("userapi/city/{shardId}/lots/name/{lotName}")]
+        public IActionResult GetByName(int shardId, string lotName)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lot = da.Lots.GetByName(shardId, lotName);
+                if (lot == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("Lot not found"));
+
+                var roomies = da.Roommates.GetLotRoommates(lot.lot_id).Where(x => x.is_pending == 0).Select(x => x.avatar_id).ToArray();
+
+                var lotJson = new JSONLot
+                {
+                    lot_id = lot.lot_id,
+                    admit_mode = lot.admit_mode,
+                    category = lot.category,
+                    created_date = lot.created_date,
+                    description = lot.description,
+                    location = lot.location,
+                    name = lot.name,
+                    neighborhood_id = lot.neighborhood_id,
+                    owner_id = lot.owner_id,
+                    shard_id = lot.shard_id,
+                    skill_mode = lot.skill_mode,
+                    roommates = roomies
+                };
+
+                return ApiResponse.Json(HttpStatusCode.OK, lotJson);
+            }
+        }
+        //get online lots
+        [HttpGet]
+        [Route("userapi/city/{shardId}/lots/online")]
+        public IActionResult GetOnline(int shardId, [FromQuery(Name = "compact")]bool compact)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                List<JSONLotSmall> lotSmallJson = new List<JSONLotSmall>();
+                var lotsOnlineJson = new JSONLotsOnline();
+                
+                if (!compact)
+                {
+                    var activeLots = da.LotClaims.AllActiveLots(shardId);
+                    if (activeLots == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("Lots not found"));
+                    var totalAvatars = 0;
+                    foreach (var lot in activeLots)
+                    {
+                        lotSmallJson.Add(new JSONLotSmall
+                        {
+                            location = lot.location,
+                            name = lot.name,
+                            description = lot.description,
+                            category = lot.category,
+                            admit_mode = lot.admit_mode,
+                            neighborhood_id = lot.neighborhood_id,
+                            avatars_in_lot = lot.active,
+                            lot_id = lot.lot_id
+                        });
+                        totalAvatars += lot.active;
+                    }
+                    lotsOnlineJson.total_lots_online = activeLots.Count();
+                    lotsOnlineJson.total_avatars_in_lots_online = totalAvatars;
+                }
+                else
+                {
+                    var activeLots = da.LotClaims.AllLocations(shardId);
+                    if (activeLots == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("Lots not found"));
+                    var totalAvatars = 0;
+                    foreach (var lot in activeLots)
+                    {
+                        totalAvatars += lot.active;
+                    }
+
+                    lotsOnlineJson.total_lots_online = activeLots.Count();
+                    lotsOnlineJson.total_avatars_in_lots_online = totalAvatars;
+                }
+
+                lotsOnlineJson.lots = lotSmallJson;
+                return ApiResponse.Json(HttpStatusCode.OK, lotsOnlineJson);
+            }
+        }
+        //get Top-100 lots by category
+        [HttpGet]
+        [Route("userapi/city/{shardId}/lots/top100/category/{lotCategory}")]
+        public IActionResult GetTop100ByCategory(int shardId, LotCategory lotCategory)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lots = da.LotTop100.GetByCategory(shardId, lotCategory).Take(100);
+                if (lots == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("Top100 lots not found"));
+
+                List<JSONTop100Lot> top100Lots = new List<JSONTop100Lot>();
+                foreach (var top100Lot in lots)
+                {
+                    top100Lots.Add(new JSONTop100Lot
+                    {
+                        category = top100Lot.category,
+                        rank = top100Lot.rank,
+                        shard_id = top100Lot.shard_id,
+                        lot_location = top100Lot.lot_location,
+                        lot_name = top100Lot.lot_name,
+                        lot_id = top100Lot.lot_id
+                    });
+                }
+                var top100Json = new JSONTop100Lots();
+                top100Json.lots = top100Lots;
+                return ApiResponse.Json(HttpStatusCode.OK, top100Json);
+            }
+        }
+        //get Top-100 lots by shard
+        [HttpGet]
+        [Route("userapi/city/{shardId}/lots/top100/all")]
+        public IActionResult GetTop100ByShard(int shardId)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lots = da.LotTop100.GetAllByShard(shardId);
+                if (lots == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONLotError("Lots not found"));
+
+                List<JSONTop100Lot> top100Lots = new List<JSONTop100Lot>();
+                foreach (var top100Lot in lots)
+                {
+                    top100Lots.Add(new JSONTop100Lot
+                    {
+                        category = top100Lot.category,
+                        rank = top100Lot.rank,
+                        shard_id = top100Lot.shard_id,
+                        lot_location = top100Lot.lot_location,
+                        lot_name = top100Lot.lot_name,
+                        lot_id = top100Lot.lot_id
+                    });
+                }
+                var top100Json = new JSONTop100Lots();
+                top100Json.lots = top100Lots;
+                return ApiResponse.Json(HttpStatusCode.OK, top100Json);
+            }
+        }
+
+        //moderation only functions, such as downloading lot state
+        [HttpGet]
+        [Route("userapi/city/{shardid}/{id}.fsov")]
+        public IActionResult GetFSOV(int shardid, uint id)
+        {
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lot = da.Lots.GetByLocation(shardid, id);
+                if (lot == null) return NotFound();
+
+                FileStream stream;
+                try
+                {
+                    var path = Path.Combine(api.Config.NFSdir, "Lots/" + lot.lot_id.ToString("x8") + "/state_" + lot.ring_backup_num.ToString() + ".fsov");
+                    
+
+                    stream = System.IO.File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
+                    return File(stream, "application/octet-stream");
+                }
+                catch (Exception e)
+                {
+                    return NotFound();
+                }
+            }
+        }
+
+        [HttpGet]
+        [Route("userapi/city/{shardid}/{id}.fsof")]
+        [ResponseCache(Duration = 60 * 60, Location = ResponseCacheLocation.Any)]
+        public IActionResult GetFSOF(int shardid, uint id)
+        {
+            var dat = (byte[])MemoryCacher.GetValue("lf" + shardid + ":" + id);
+            if (dat != null)
+            {
+                return File(dat, "application/octet-stream");
+            }
+
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lot = IDForLocation(shardid, id);
+                if (lot == null) return NotFound();
+
+                FileStream stream;
+                try
+                {
+                    var path = Path.Combine(api.Config.NFSdir, "Lots/" + lot.Value.ToString("x8") + "/thumb.fsof");
+
+                    var ndat = System.IO.File.ReadAllBytes(path);
+                    MemoryCacher.Add("lf" + shardid + ":" + id, ndat, DateTime.Now.Add(new TimeSpan(1, 0, 0)));
+                    return File(ndat, "application/octet-stream");
+                }
+                catch (Exception e)
+                {
+                    return NotFound();
+                }
+            }
+        }
+
+        [HttpPost]
+        [Route("userapi/city/{shardid}/uploadfacade/{id}")]
+        public IActionResult UploadFacade(int shardid, uint id, List<IFormFile> files)
+        {
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+
+            if (files == null)
+                return NotFound();
+
+            byte[] data = null;
+            foreach (var file in files)
+            {
+                var filename = file.FileName.Trim('\"');
+                using (var memoryStream = new MemoryStream())
+                {
+                    file.CopyTo(memoryStream);
+                    data = memoryStream.ToArray();
+                }
+            }
+
+            if (data == null) return NotFound();
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lot = da.Lots.GetByLocation(shardid, id);
+                if (lot == null) return NotFound();
+
+                FileStream stream;
+                try
+                {
+                    var path = Path.Combine(api.Config.NFSdir, "Lots/" + lot.lot_id.ToString("x8") + "/thumb.fsof");
+                    stream = System.IO.File.Open(path, FileMode.Create, FileAccess.Write, FileShare.Write);
+                    stream.Write(data, 0, data.Length);
+                    return Ok();
+                }
+                catch (Exception e)
+                {
+                    return NotFound();
+                }
+            }
+
+            /*
+            var api = Api.INSTANCE;
+            api.DemandModerator(Request);
+
+            if (!Request.Content.IsMimeMultipartContent())
+                return new HttpResponseMessage(HttpStatusCode.UnsupportedMediaType);
+
+            var provider = new MultipartMemoryStreamProvider();
+            var files = Request.Content.ReadAsMultipartAsync(provider).Result;
+
+            byte[] data = null;
+            foreach (var file in provider.Contents)
+            {
+                var filename = file.Headers.ContentDisposition.FileName.Trim('\"');
+                data = file.ReadAsByteArrayAsync().Result;
+            }
+
+            if (data == null) return new HttpResponseMessage(HttpStatusCode.NotFound);
+
+            using (var da = api.DAFactory.Get())
+            {
+                var lot = da.Lots.GetByLocation(shardid, id);
+                if (lot == null) return new HttpResponseMessage(HttpStatusCode.NotFound);
+
+                FileStream stream;
+                try
+                {
+                    var path = Path.Combine(api.Config.NFSdir, "Lots/" + lot.lot_id.ToString("x8") + "/thumb.fsof");
+                    stream = System.IO.File.Open(path, FileMode.Create, FileAccess.Write, FileShare.Write);
+                    stream.Write(data, 0, data.Length);
+
+                    HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
+                    response.Content = new StringContent("", Encoding.UTF8, "text/plain");
+                    return response;
+                }
+                catch (Exception e)
+                {
+                    return new HttpResponseMessage(HttpStatusCode.NotFound);
+                }
+            }
+            */
+        }
+    }
+
+
+    public class ShardLocationCache
+    {
+        public ConcurrentDictionary<uint, int> Dict = new ConcurrentDictionary<uint, int>();
+        public DateTime CreateTime = DateTime.UtcNow;
+
+        public ShardLocationCache(ConcurrentDictionary<uint, int> dict)
+        {
+            Dict = dict;
+        }
+    }
+    public class JSONLotError
+    {
+        public string error;
+        public JSONLotError(string errorString)
+        {
+            error = errorString;
+        }
+    }
+    public class JSONLotsSmall
+    {
+        public List<JSONLotSmall> lots { get; set; }
+    }
+    public class JSONLots
+    {
+        public List<JSONLot> lots { get; set; }
+    }
+    public class JSONLotsPage
+    {
+        public int page { get; set; }
+        public int total_pages { get; set; }
+        public int total_lots { get; set; }
+        public int lots_on_page { get; set; }
+        public List<JSONLotSmall> lots { get; set; }
+    }
+    public class JSONLotsOnline
+    {
+        public int total_lots_online { get; set; }
+        public int total_avatars_in_lots_online { get; set; }
+        public List<JSONLotSmall> lots { get; set; }
+    }
+    public class JSONLotSmall
+    {
+        public int lot_id { get; set; }
+        public uint location { get; set; }
+        public string name { get; set; }
+        public string description { get; set; }
+        public LotCategory category { get; set; }
+        public uint admit_mode { get; set; }
+        public uint neighborhood_id { get; set; }
+        public int avatars_in_lot { get; set; }
+    }
+    public class JSONLot
+    {
+        public int lot_id { get; set; }
+        public int shard_id { get; set; }
+        public uint? owner_id { get; set; }
+        public uint[] roommates { get; set; }
+        public string name { get; set; }
+        public string description { get; set; }
+        public uint location { get; set; }
+        public uint neighborhood_id { get; set; }
+        public uint created_date { get; set; }
+        public LotCategory category { get; set; }
+        public byte skill_mode { get; set; }
+        public byte admit_mode { get; set; }
+    }
+    public class JSONTop100Lots
+    {
+        public List<JSONTop100Lot> lots { get; set; }
+    }
+    public class JSONTop100Lot
+    {
+        public LotCategory category { get; set; }
+        public byte rank { get; set; }
+        public int shard_id { get; set; }
+        public string lot_name { get; set; }
+        public uint? lot_location { get; set; }
+        public int? lot_id { get; set; }
+    }
+}

server/FSO.Server.Api.Core/Controllers/NhoodInfoController.cs

@@ -0,0 +1,128 @@
+using FSO.Server.Api.Core.Utils;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [EnableCors]
+    [ApiController]
+    public class NhoodInfoController : ControllerBase
+    {
+        [HttpGet]
+        [Route("userapi/city/{shardId}/neighborhoods/all")]
+        public IActionResult GetAll(int shardId)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var nhoods = da.Neighborhoods.All(shardId);
+                if (nhoods == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONNhoodError("Neighborhoods not found"));
+
+                List<JSONNhood> nhoodJson = new List<JSONNhood>();
+                foreach (var nhood in nhoods)
+                {
+                    nhoodJson.Add(new JSONNhood
+                    {
+                        neighborhood_id = nhood.neighborhood_id,
+                        name = nhood.name,
+                        description = nhood.description,
+                        color = nhood.color,
+                        town_hall_id = nhood.town_hall_id,
+                        icon_url = nhood.icon_url,
+                        mayor_id = nhood.mayor_id,
+                        mayor_elected_date = nhood.mayor_elected_date,
+                        election_cycle_id = nhood.election_cycle_id
+                    });
+
+                }
+                var nhoodsJson = new JSONNhoods();
+                nhoodsJson.neighborhoods = nhoodJson;
+                return ApiResponse.Json(HttpStatusCode.OK, nhoodsJson);
+            }
+        }
+        [HttpGet]
+        [Route("userapi/neighborhoods/{nhoodId}")]
+        public IActionResult GetByID(uint nhoodId)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var nhood = da.Neighborhoods.Get(nhoodId);
+                if (nhood == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONNhoodError("Neighborhood not found"));
+
+                var nhoodJson = new JSONNhood
+                {
+                    neighborhood_id = nhood.neighborhood_id,
+                    name = nhood.name,
+                    description = nhood.description,
+                    color = nhood.color,
+                    town_hall_id = nhood.town_hall_id,
+                    icon_url = nhood.icon_url,
+                    mayor_id = nhood.mayor_id,
+                    mayor_elected_date = nhood.mayor_elected_date,
+                    election_cycle_id = nhood.election_cycle_id
+                };
+                return ApiResponse.Json(HttpStatusCode.OK, nhoodJson);
+            }
+        }
+        [HttpGet]
+        [Route("userapi/city/{shardId}/neighborhoods/name/{nhoodName}")]
+        public IActionResult GetByName(int shardId, string nhoodName)
+        {
+            var api = Api.INSTANCE;
+
+            using (var da = api.DAFactory.Get())
+            {
+                var searchNhood = da.Neighborhoods.SearchExact(shardId, nhoodName, 1).FirstOrDefault();
+                if (searchNhood == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONNhoodError("Neighborhood not found"));
+
+                var nhood = da.Neighborhoods.Get((uint)searchNhood.neighborhood_id);
+                if (nhood == null) return ApiResponse.Json(HttpStatusCode.NotFound, new JSONNhoodError("Neighborhood not found"));
+
+                var nhoodJson = new JSONNhood
+                {
+                    neighborhood_id = nhood.neighborhood_id,
+                    name = nhood.name,
+                    description = nhood.description,
+                    color = nhood.color,
+                    town_hall_id = nhood.town_hall_id,
+                    icon_url = nhood.icon_url,
+                    mayor_id = nhood.mayor_id,
+                    mayor_elected_date = nhood.mayor_elected_date,
+                    election_cycle_id = nhood.election_cycle_id
+                };
+                return ApiResponse.Json(HttpStatusCode.OK, nhoodJson);
+            }
+        }
+    }
+    public class JSONNhoodError
+    {
+        public string error;
+        public JSONNhoodError(string errorString)
+        {
+            error = errorString;
+        }
+    }
+    public class JSONNhoods
+    {
+        public List<JSONNhood> neighborhoods { get; set; }
+    }
+    public class JSONNhood
+    {
+        public int neighborhood_id { get; set; }
+        public string name { get; set; }
+        public string description { get; set; }
+        public uint color { get; set; }
+        public int? town_hall_id { get; set; }
+        public string icon_url { get; set; }
+        public uint? mayor_id { get; set; }
+        public uint mayor_elected_date { get; set; }
+        public uint? election_cycle_id { get; set; }
+
+    }
+}

server/FSO.Server.Api.Core/Controllers/RegistrationController.cs

@@ -0,0 +1,616 @@
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Common;
+using FSO.Server.Database.DA.EmailConfirmation;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using System.Linq;
+using System.Net;
+using System.Text.RegularExpressions;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    /// <summary>
+    /// Controller for user registrations.
+    /// Supports email confirmation if enabled in config.json.
+    /// </summary>
+
+    [EnableCors]
+    [Route("userapi/registration")]
+    [ApiController]
+    public class RegistrationController : ControllerBase
+    {
+        private const int REGISTER_THROTTLE_SECS = 60;
+        private const int EMAIL_CONFIRMATION_EXPIRE = 2 * 60 * 60; // 2 hrs
+
+        /// <summary>
+        /// Alphanumeric (lowercase), no whitespace or special chars, cannot start with an underscore.
+        /// </summary>
+        private static Regex USERNAME_VALIDATION = new Regex("^([a-z0-9]){1}([a-z0-9_]){2,23}$");
+
+        #region Registration
+        [HttpPost]
+        public IActionResult CreateUser([FromForm] RegistrationModel user)
+        {
+            var api = Api.INSTANCE;
+
+            if(api.Config.SmtpEnabled)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "registration_failed",
+                    error_description = "missing_confirmation_token"
+                });
+            }
+
+            var ip = ApiUtils.GetIP(Request);
+
+            user.username = user.username ?? "";
+            user.username = user.username.ToLowerInvariant();
+            user.email = user.email ?? "";
+            //user.key = user.key ?? "";
+
+            string failReason = null;
+            if (user.username.Length < 3) failReason = "user_short";
+            else if (user.username.Length > 24) failReason = "user_long";
+            else if (!USERNAME_VALIDATION.IsMatch(user.username ?? "")) failReason = "user_invalid";
+            else if ((user.password?.Length ?? 0) == 0) failReason = "pass_required";
+
+            try
+            {
+                var addr = new System.Net.Mail.MailAddress(user.email);
+            }
+            catch
+            {
+                failReason = "email_invalid";
+            }
+
+            if (failReason != null)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "bad_request",
+                    error_description = failReason
+                });
+            }
+
+            /*
+            if (!string.IsNullOrEmpty(api.Config.Regkey) && api.Config.Regkey != user.key)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "key_wrong",
+                    error_description = failReason
+                });
+            }
+            */
+
+            using (var da = api.DAFactory.Get())
+            {
+                //has this ip been banned?
+                var ban = da.Bans.GetByIP(ip);
+                if (ban != null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "registration_failed",
+                        error_description = "ip_banned"
+                    });
+                }
+
+                //has this user registered a new account too soon after their last?
+                var now = Epoch.Now;
+                var prev = da.Users.GetByRegisterIP(ip);
+                if (now - (prev.FirstOrDefault()?.register_date ?? 0) < REGISTER_THROTTLE_SECS)
+                {
+                    //cannot create a new account this soon.
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "registration_failed",
+                        error_description = "registrations_too_frequent"
+                    });
+                }
+
+                var userModel = api.CreateUser(user.username, user.email, user.password, ip);
+
+                if(userModel==null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "registration_failed",
+                        error_description = "user_exists"
+                    });
+                } else {
+                    api.SendEmailConfirmationOKMail(user.username, user.email);
+                    return ApiResponse.Json(HttpStatusCode.OK, userModel);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Create a confirmation token and send email.
+        /// </summary>
+        /// <param name="email"></param>
+        /// <returns></returns>
+        [HttpPost]
+        [Route("userapi/registration/request")]
+        public IActionResult CreateToken(ConfirmationCreateTokenModel model)
+        {
+            Api api = Api.INSTANCE;
+
+            // smtp needs to be configured for this
+            if(!api.Config.SmtpEnabled)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "registration_failed",
+                    error_description = "smtp_disabled"
+                });
+            }
+
+            if(model.confirmation_url==null||model.email==null)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "registration_failed",
+                    error_description = "missing_fields"
+                });
+            }
+
+            // verify email syntax
+            // To do: check if email address is disposable.
+            try
+            {
+                var addr = new System.Net.Mail.MailAddress(model.email);
+            }
+            catch
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "registration_failed",
+                    error_description = "email_invalid"
+                });
+            }
+
+            using (var da = api.DAFactory.Get())
+            {
+                // email is taken
+                if(da.Users.GetByEmail(model.email)!=null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "registration_failed",
+                        error_description = "email_taken"
+                    });
+                }
+
+                EmailConfirmation confirm = da.EmailConfirmations.GetByEmail(model.email, ConfirmationType.email);
+
+                // already waiting for confirmation
+                if(confirm!=null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "registration_failed",
+                        error_description = "confirmation_pending"
+                    });
+                }
+
+                uint expires = Epoch.Now + EMAIL_CONFIRMATION_EXPIRE;
+
+                // create new email confirmation
+                string token = da.EmailConfirmations.Create(new EmailConfirmation
+                {
+                    type = ConfirmationType.email,
+                    email = model.email,
+                    expires = expires
+                });
+
+                // send email with recently generated token
+                bool sent = api.SendEmailConfirmationMail(model.email, token, model.confirmation_url, expires);
+                 
+                if(sent)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new
+                    {
+                        status = "success"
+                    });
+                }
+
+                return ApiResponse.Json(HttpStatusCode.OK, new
+                {
+                    status = "email_failed"
+                });
+               
+            }
+        }
+
+        /// <summary>
+        /// Create a user with a valid email confirmation token.
+        /// </summary>
+        /// <param name="user"></param>
+        /// <returns></returns>
+        [HttpPost]
+        [Route("userapi/registration/confirm")]
+        public IActionResult CreateUserWithToken(RegistrationUseTokenModel user)
+        {
+            Api api = Api.INSTANCE;
+
+            if (user == null)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "registration_failed",
+                    error_description = "invalid_token"
+                });
+            }
+
+            using (var da = api.DAFactory.Get())
+            {
+                EmailConfirmation confirmation = da.EmailConfirmations.GetByToken(user.token);
+
+                if(confirmation == null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "registration_failed",
+                        error_description = "invalid_token"
+                    });
+                }
+
+                var ip = ApiUtils.GetIP(Request);
+
+                user.username = user.username ?? "";
+                user.username = user.username.ToLowerInvariant();
+                user.email = user.email ?? "";
+                user.key = user.key ?? "";
+
+                string failReason = null;
+                if (user.username.Length < 3) failReason = "user_short";
+                else if (user.username.Length > 24) failReason = "user_long";
+                else if (!USERNAME_VALIDATION.IsMatch(user.username ?? "")) failReason = "user_invalid";
+                else if ((user.password?.Length ?? 0) == 0) failReason = "pass_required";
+
+                try
+                {
+                    var addr = new System.Net.Mail.MailAddress(user.email);
+                }
+                catch
+                {
+                    failReason = "email_invalid";
+                }
+
+                if (failReason != null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "bad_request",
+                        error_description = failReason
+                    });
+                }
+
+                if (!string.IsNullOrEmpty(api.Config.Regkey) && api.Config.Regkey != user.key)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "key_wrong",
+                        error_description = failReason
+                    });
+                }
+
+                //has this ip been banned?
+                var ban = da.Bans.GetByIP(ip);
+                if (ban != null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "registration_failed",
+                        error_description = "ip_banned"
+                    });
+                }
+
+                //has this user registered a new account too soon after their last?
+                var prev = da.Users.GetByRegisterIP(ip);
+                if (Epoch.Now - (prev.FirstOrDefault()?.register_date ?? 0) < REGISTER_THROTTLE_SECS)
+                {
+                    //cannot create a new account this soon.
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "registration_failed",
+                        error_description = "registrations_too_frequent"
+                    });
+                }
+
+                //create user in db
+                var userModel = api.CreateUser(user.username, user.email, user.password, ip);
+
+                if (userModel == null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "registration_failed",
+                        error_description = "user_exists"
+                    });
+                }
+                else
+                {
+                    //send OK email
+                    api.SendEmailConfirmationOKMail(user.username, user.email);
+                    da.EmailConfirmations.Remove(user.token);
+                    return ApiResponse.Json(HttpStatusCode.OK, userModel);
+                }
+            }
+        }
+
+        #endregion
+
+        #region Password reset
+        [HttpPost]
+        [Route("userapi/password")]
+        public IActionResult ChangePassword(PasswordResetModel model)
+        {
+            Api api = Api.INSTANCE;
+
+            if (api.Config.SmtpEnabled)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "password_reset_failed",
+                    error_description = "missing_confirmation_token"
+                });
+            }
+
+            // No empty fields
+            if (model.username==null||model.new_password==null||model.old_password==null)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "password_reset_failed",
+                    error_description = "missing_fields"
+                });
+            }
+
+            using (var da = api.DAFactory.Get())
+            {
+                var user = da.Users.GetByUsername(model.username);
+
+                if(user==null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "password_reset_failed",
+                        error_description = "user_invalid"
+                    });
+                }
+
+                var authSettings = da.Users.GetAuthenticationSettings(user.user_id);
+                var correct = PasswordHasher.Verify(model.old_password, new PasswordHash
+                {
+                    data = authSettings.data,
+                    scheme = authSettings.scheme_class
+                });
+
+                if (!correct)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "password_reset_failed",
+                        error_description = "incorrect_password"
+                    });
+                }
+
+                api.ChangePassword(user.user_id, model.new_password);
+                api.SendPasswordResetOKMail(user.email, user.username);
+
+                return ApiResponse.Json(HttpStatusCode.OK, new
+                {
+                    status = "success"
+                });
+            }
+        }
+
+        /// <summary>
+        /// Resets a user's password using a confirmation token.
+        /// </summary>
+        /// <param name="model"></param>
+        /// <returns></returns>
+        [HttpPost]
+        [Route("userapi/password/confirm")]
+        public IActionResult ConfirmPwd(PasswordResetUseTokenModel model)
+        {
+            Api api = Api.INSTANCE;
+
+            if(model.token==null||model.new_password==null)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "password_reset_failed",
+                    error_description = "missing_fields"
+                });
+            }
+
+            using (var da = api.DAFactory.Get())
+            {
+                EmailConfirmation confirmation = da.EmailConfirmations.GetByToken(model.token);
+
+                if(confirmation==null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "password_reset_failed",
+                        error_description = "invalid_token"
+                    });
+                }
+
+                var user = da.Users.GetByEmail(confirmation.email);
+
+                api.ChangePassword(user.user_id, model.new_password);
+                api.SendPasswordResetOKMail(user.email, user.username);
+                da.EmailConfirmations.Remove(model.token);
+
+                return ApiResponse.Json(HttpStatusCode.OK, new
+                {
+                    status = "success"
+                });
+            }
+        }
+
+        /// <summary>
+        /// Creates a password reset token and mails it to the user.
+        /// </summary>
+        /// <param name="model"></param>
+        /// <returns></returns>
+        [HttpPost]
+        [Route("userapi/password/request")]
+        public IActionResult CreatePwdToken(ConfirmationCreateTokenModel model)
+        {  
+            Api api = Api.INSTANCE;
+
+            if (model.confirmation_url == null || model.email == null)
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "password_reset_failed",
+                    error_description = "missing_fields"
+                });
+            }
+
+            // verify email syntax
+            // To do: check if email address is disposable.
+            try
+            {
+                var addr = new System.Net.Mail.MailAddress(model.email);
+            }
+            catch
+            {
+                return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                {
+                    error = "password_reset_failed",
+                    error_description = "email_invalid"
+                });
+            }
+
+            using (var da = api.DAFactory.Get())
+            {
+
+                var user = da.Users.GetByEmail(model.email);
+
+                if(user==null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "password_reset_failed",
+                        error_description = "email_invalid"
+                    });
+                }
+
+                EmailConfirmation confirm = da.EmailConfirmations.GetByEmail(model.email, ConfirmationType.password);
+
+                // already awaiting a confirmation
+                // to-do: resend?
+                if (confirm != null)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new RegistrationError()
+                    {
+                        error = "registration_failed",
+                        error_description = "confirmation_pending"
+                    });
+                }
+
+                uint expires = Epoch.Now + EMAIL_CONFIRMATION_EXPIRE;
+
+                // create new email confirmation
+                string token = da.EmailConfirmations.Create(new EmailConfirmation
+                {
+                    type = ConfirmationType.password,
+                    email = model.email,
+                    expires = expires
+                });
+
+                // send confirmation email with generated token
+                bool sent = api.SendPasswordResetMail(model.email, user.username, token, model.confirmation_url, expires);
+
+                if (sent)
+                {
+                    return ApiResponse.Json(HttpStatusCode.OK, new
+                    {
+                        status = "success"
+                    });
+                }
+
+                return ApiResponse.Json(HttpStatusCode.OK, new
+                {
+                    // success but email shitfaced
+                    status = "email_failed"
+                });
+            }
+        }
+
+        #endregion
+    }
+
+    #region Models
+    public class RegistrationError
+    {
+        public string error_description { get; set; }
+        public string error { get; set; }
+    }
+
+    public class RegistrationModel
+    {
+        public string username { get; set; }
+        public string email { get; set; }
+        public string password { get; set; }
+    }
+
+    /// <summary>
+    /// Expected request data when trying to create a token to register.
+    /// </summary>
+    public class ConfirmationCreateTokenModel
+    {
+        public string email { get; set; }
+        /// <summary>
+        /// The link the user will have to go to in order to confirm their token.
+        /// If %token% is present in the url, it will be replaced with the user's token.
+        /// </summary>
+        public string confirmation_url { get; set; }
+    }
+
+    public class PasswordResetModel
+    {
+        public string username { get; set; }
+        public string old_password { get; set; }
+        public string new_password { get; set; }
+    }
+
+    /// <summary>
+    /// Expected request data when trying to register with a token.
+    /// </summary>
+    public class RegistrationUseTokenModel
+    {
+        public string username { get; set; }
+        /// <summary>
+        /// User email.
+        /// </summary>
+        public string email { get; set; }
+        /// <summary>
+        /// User password.
+        /// </summary>
+        public string password { get; set; }
+        /// <summary>
+        /// Registration key.
+        /// </summary>
+        public string key { get; set; }
+        /// <summary>
+        /// The unique GUID.
+        /// </summary>
+        public string token { get; set; }
+    }
+
+    public class PasswordResetUseTokenModel
+    {
+        public string token { get; set; }
+        public string new_password { get; set; }
+    }
+
+    #endregion
+}

server/FSO.Server.Api.Core/Controllers/ShardSelectorController.cs

@@ -0,0 +1,98 @@
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Common;
+using FSO.Server.Database.DA.Shards;
+using FSO.Server.Protocol.CitySelector;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Net;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [Route("cityselector/app/ShardSelectorServlet")]
+    [ApiController]
+    public class ShardSelectorController : ControllerBase
+    {
+        private static Func<IActionResult> ERROR_SHARD_NOT_FOUND = ApiResponse.XmlFuture(HttpStatusCode.OK, new XMLErrorMessage("503", "Shard not found"));
+        private static Func<IActionResult> ERROR_AVATAR_NOT_FOUND = ApiResponse.XmlFuture(HttpStatusCode.OK, new XMLErrorMessage("504", "Avatar not found"));
+        private static Func<IActionResult> ERROR_AVATAR_NOT_YOURS = ApiResponse.XmlFuture(HttpStatusCode.OK, new XMLErrorMessage("505", "You do not own this avatar!"));
+        private static Func<IActionResult> ERROR_BANNED = ApiResponse.XmlFuture(HttpStatusCode.OK, new XMLErrorMessage("506", "Your account has been banned."));
+        private static Func<IActionResult> ERROR_MAINTAINANCE = ApiResponse.XmlFuture(HttpStatusCode.OK, new XMLErrorMessage("507", "The server is currently undergoing maintainance. Please try again later."));
+
+        public IActionResult Get(string shardName, string avatarId)
+        {
+            var api = Api.INSTANCE;
+
+            var user = api.RequireAuthentication(Request);
+            if (avatarId == null){
+                //Using 0 to mean no avatar for CAS
+                avatarId = "0";
+            }
+
+            using (var db = api.DAFactory.Get())
+            {
+                ShardStatusItem shard = api.Shards.GetByName(shardName);
+                if (shard != null)
+                {
+                    var ip = ApiUtils.GetIP(Request);
+                    uint avatarDBID = uint.Parse(avatarId);
+
+                    if (avatarDBID != 0)
+                    {
+                        var avatar = db.Avatars.Get(avatarDBID);
+                        if (avatar == null)
+                        {
+                            //can't join server with an avatar that doesn't exist
+                            return ERROR_AVATAR_NOT_FOUND();
+                        }
+                        if (avatar.user_id != user.UserID || avatar.shard_id != shard.Id)
+                        {
+                            //make sure we own the avatar we're trying to connect with
+                            return ERROR_AVATAR_NOT_YOURS();
+                        }
+                    }
+
+                    var ban = db.Bans.GetByIP(ip);
+                    var dbuser = db.Users.GetById(user.UserID);
+                    if (dbuser == null || ban != null || dbuser.is_banned != false)
+                    {
+                        return ERROR_BANNED();
+                    }
+
+                    if (api.Config.Maintainance && !(dbuser.is_admin || dbuser.is_moderator))
+                    {
+                        return ERROR_MAINTAINANCE();
+                    }
+
+                    /** Make an auth ticket **/
+                    var ticket = new ShardTicket
+                    {
+                        ticket_id = Guid.NewGuid().ToString().Replace("-", ""),
+                        user_id = user.UserID,
+                        avatar_id = avatarDBID,
+                        date = Epoch.Now,
+                        ip = ip
+                    };
+
+                    db.Users.UpdateConnectIP(ticket.user_id, ip);
+                    db.Shards.CreateTicket(ticket);
+
+                    var result = new ShardSelectorServletResponse();
+                    result.PreAlpha = false;
+
+                    result.Address = shard.PublicHost;
+                    result.PlayerID = user.UserID;
+                    result.AvatarID = avatarId;
+                    result.Ticket = ticket.ticket_id;
+                    result.ConnectionID = ticket.ticket_id;
+                    result.AvatarID = avatarId;
+
+                    return ApiResponse.Xml(HttpStatusCode.OK, result);
+                }
+                else
+                {
+                    return ERROR_SHARD_NOT_FOUND();
+                }
+            }
+        }
+    }
+}

server/FSO.Server.Api.Core/Controllers/ShardStatusController.cs

@@ -0,0 +1,29 @@
+using FSO.Common.Utils;
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Protocol.CitySelector;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using System.Net;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [EnableCors]
+    [Route("cityselector/shard-status.jsp")]
+    [ApiController]
+    public class ShardStatusController : ControllerBase
+    {
+        [HttpGet]
+        public IActionResult Get()
+        {
+            var api = Api.INSTANCE;
+
+            var result = new XMLList<ShardStatusItem>("Shard-Status-List");
+            var shards = api.Shards.All;
+            foreach (var shard in shards)
+            {
+                result.Add(shard);
+            }
+            return ApiResponse.Xml(HttpStatusCode.OK, result);
+        }
+    }
+}

server/FSO.Server.Api.Core/Controllers/UserOAuthController.cs

@@ -0,0 +1,122 @@
+using FSO.Server.Api.Core.Utils;
+using FSO.Server.Common;
+using FSO.Server.Servers.Api.JsonWebToken;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Collections.Generic;
+
+namespace FSO.Server.Api.Core.Controllers
+{
+    [Route("userapi/oauth/token")]
+    [ApiController]
+    public class UserOAuthController : ControllerBase
+    {
+        [HttpPost]
+        public IActionResult CreateToken([FromForm] UserOAuthRequest userAuthRequest)
+        {
+            if (userAuthRequest == null) BadRequest();
+            var api = Api.INSTANCE;
+            using (var da = api.DAFactory.Get())
+            {
+                var user = da.Users.GetByUsername(userAuthRequest.username);
+                if (user == null || user.is_banned) return ApiResponse.Json(System.Net.HttpStatusCode.Unauthorized, new UserOAuthError("unauthorized_client", "user_credentials_invalid"));
+                var ip = ApiUtils.GetIP(Request);
+                var hashSettings = da.Users.GetAuthenticationSettings(user.user_id);
+                var isPasswordCorrect = PasswordHasher.Verify(userAuthRequest.password, new PasswordHash
+                {
+                    data = hashSettings.data,
+                    scheme = hashSettings.scheme_class
+                });
+                //check if account is locked due to failed attempts
+                var accLock = da.Users.GetRemainingAuth(user.user_id, ip);
+                if (accLock != null && (accLock.active || accLock.count >= AuthLoginController.LockAttempts) && accLock.expire_time > Epoch.Now)
+                {
+                    return ApiResponse.Json(System.Net.HttpStatusCode.OK, new UserOAuthError("unauthorized_client", "account_locked"));
+                }
+                //if the password is incorrect and check if user failed muli times and set a time out till next try.
+                if (!isPasswordCorrect)
+                {
+                    var durations = AuthLoginController.LockDuration;
+                    var failDelay = 60 * durations[Math.Min(durations.Length - 1, da.Users.FailedConsecutive(user.user_id, ip))];
+                    if (accLock == null)
+                    {
+                        da.Users.NewFailedAuth(user.user_id, ip, (uint)failDelay);
+                    }
+                    else
+                    {
+                        var remaining = da.Users.FailedAuth(accLock.attempt_id, (uint)failDelay, AuthLoginController.LockAttempts);
+                    }
+                    return ApiResponse.Json(System.Net.HttpStatusCode.OK, new UserOAuthError("unauthorized_client", "user_credentials_invalid"));
+                }
+
+                //user passed the password check, and now creates the claim/token
+                da.Users.SuccessfulAuth(user.user_id, ip);
+                var claims = new List<string>();
+
+                //set the permission level in the claim
+                switch (userAuthRequest.permission_level)
+                {
+                    case 1:
+                        claims.Add("userReadPermissions");
+                        break;
+                    case 2:
+                        claims.Add("userReadPermissions");
+                        claims.Add("userWritePermissions");
+                        break;
+                    case 3:
+                        claims.Add("userReadPermissions");
+                        claims.Add("userWritePermissions");
+                        claims.Add("userUpdatePermissions");
+                        break;
+                    case 4:
+                        claims.Add("userReadPermissions");
+                        claims.Add("userWritePermissions");
+                        claims.Add("userUpdatePermissions");
+                        claims.Add("userDeletePermissions");
+                        break;
+                    default:
+                        break;
+                }
+                
+                //set the user identity
+                JWTUser identity = new JWTUser
+                {
+                    UserID = user.user_id,
+                    UserName = user.username,
+                    Claims = claims
+                };
+
+                //generate the the tokenen and send it in a JSON format as response
+                var generatedToken = api.JWT.CreateToken(identity);
+                return ApiResponse.Json(System.Net.HttpStatusCode.OK, new UserOAuthSuccess
+                {
+                    access_token = generatedToken.Token,
+                    expires_in = generatedToken.ExpiresIn
+                });
+            }
+            
+        }
+    }
+    public class UserOAuthRequest
+    {
+        public int permission_level { get; set; }
+        public string username { get; set; }
+        public string password { get; set; }
+    }
+    public class UserOAuthError
+    {
+        public string error;
+        public string error_description;
+        public UserOAuthError(string errorString,string errorDescriptionString)
+        {
+            error = errorString;
+            error_description = errorDescriptionString;
+        }
+    }
+    public class UserOAuthSuccess
+    {
+        public string access_token { get; set; }
+        public int expires_in { get; set; }
+    }
+
+}

server/FSO.Server.Api.Core/FSO.Server.Api.Core.csproj

@@ -0,0 +1,66 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
+    <TargetLatestRuntimePatch>true</TargetLatestRuntimePatch>
+	<ErrorOnDuplicatePublishOutputFiles>false</ErrorOnDuplicatePublishOutputFiles>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Remove="MailTemplates\MailBan.html" />
+    <None Remove="MailTemplates\MailBase.html" />
+    <None Remove="MailTemplates\MailPasswordReset.html" />
+    <None Remove="MailTemplates\MailPasswordResetOK.html" />
+    <None Remove="MailTemplates\MailRegistrationOK.html" />
+    <None Remove="MailTemplates\MailRegistrationToken.html" />
+    <None Remove="MailTemplates\MailUnban.html" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="MailTemplates\MailBan.html">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="MailTemplates\MailBase.html">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="MailTemplates\MailPasswordReset.html">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="MailTemplates\MailPasswordResetOK.html">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="MailTemplates\MailRegistrationOK.html">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="MailTemplates\MailRegistrationToken.html">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="MailTemplates\MailUnban.html">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="wwwroot\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AWSSDK.Core" Version="3.3.103.48" />
+    <PackageReference Include="AWSSDK.S3" Version="3.3.104.36" />
+    <PackageReference Include="Microsoft.AspNetCore.All" Version="2.2.7" />
+    <PackageReference Include="Microsoft.AspNetCore.App" />
+    <PackageReference Include="Microsoft.AspNetCore.Cors" Version="2.2.0" />
+    <PackageReference Include="Octokit" Version="0.36.0" />
+    <PackageReference Include="System.Security.Cryptography.Algorithms" Version="4.3.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\FSO.Server.Common\FSO.Server.Common.csproj" />
+    <ProjectReference Include="..\FSO.Server.Database\FSO.Server.Database.csproj" />
+    <ProjectReference Include="..\FSO.Server.Domain\FSO.Server.Domain.csproj" />
+    <ProjectReference Include="..\FSO.Server.Protocol\FSO.Server.Protocol.csproj" />
+    <ProjectReference Include="..\tso.common\FSO.Common.csproj" />
+    <ProjectReference Include="..\tso.files\FSO.Files.csproj" />
+  </ItemGroup>
+
+</Project>

server/FSO.Server.Api.Core/MailTemplates/MailBan.html

@@ -0,0 +1,13 @@
+<strong>Account Suspended.</strong>
+<br>One of your FreeSO accounts has been suspended for not following <a href="http://freeso.org/rules">the rules</a>.
+<br>Banned account username: 
+<strong>%username%</strong>.
+<br>
+<br />
+Expiration date: 
+<strong>%end%</strong>
+<br />
+<br>Official Discord:
+<a href='https://discord.gg/xveESFj'>https://discord.gg/xveESFj</a>
+<br>Forums:
+<a href='http://forum.freeso.org'>http://forum.freeso.org</a>

server/FSO.Server.Api.Core/MailTemplates/MailBase.html

@@ -0,0 +1,9 @@
+<div style='font-family:Arial;border-radius:6px;border:1px solid #3875B9;padding:20px;max-width:500px;text-align:justify;line-height:22px'>
+    <div style='display:block;padding-bottom:20px;overflow:hidden;border-bottom:1px solid #3875B9'>
+        <img style='float:left' src='https://beta.freeso.org/cdn/img/slogo.png'>
+        <span style='float:left;margin-left:15px;margin-top:15px'>Official Game Server</span>
+    </div>
+    <br />
+    %content%
+    <br />
+</div>

server/FSO.Server.Api.Core/MailTemplates/MailPasswordReset.html

@@ -0,0 +1,11 @@
+<strong>Password Reset Request</strong>
+<br>You requested a password reset. Good news, it's here!
+<br><a href='%confirmation_url%'>Click here to change your password</a>. The link will expire in %expires%.
+<br>Just in case, your token is: %token%.
+<br />
+<br>Official Discord: <a href='https://discord.gg/xveESFj'>https://discord.gg/xveESFj</a>
+<br>Forums: <a href='http://forum.freeso.org'>http://forum.freeso.org</a>
+<br>Twitter: <a href='http://twitter.com/FreeSOGame'>http://twitter.com/FreeSOGame</a>
+<br>
+<br><strong>Download the FreeSO Installer</strong>
+<br>Get the installer from <a href='http://beta.freeso.org'>FreeSO.org</a>. After confirming your account by clicking the link above, you will be able to create an account and login.

server/FSO.Server.Api.Core/MailTemplates/MailPasswordResetOK.html

@@ -0,0 +1,10 @@
+<strong>Your account password was just changed.</strong>
+<br>The password for your account with username <strong>%username%</strong> was just changed.
+<br />
+<br>Official Discord: <a href='https://discord.gg/xveESFj'>https://discord.gg/xveESFj</a>
+<br>Forums: <a href='http://forum.freeso.org'>http://forum.freeso.org</a>
+<br>Twitter: <a href='http://twitter.com/FreeSOGame'>http://twitter.com/FreeSOGame</a>
+<br>
+<br>
+<strong>Learn how to get started:</strong>
+<br>Check out TSOMania's guide at <a href="http://www.tsomania.net/gameguides/getting_started.php">TSOMania.net</a>.

server/FSO.Server.Api.Core/MailTemplates/MailRegistrationOK.html

@@ -0,0 +1,12 @@
+<strong>Welcome to Sunrise Crater!</strong>
+<br>You can now login in-game. Here are your details:
+<br>Your username is: <strong>%username%</strong>. If you need any further support message us on one of our platforms.
+<br>Please check out <a href="http://freeso.org/rules">the rules</a> if you haven't already!
+<br />
+<br>Official Discord: <a href='https://discord.gg/xveESFj'>https://discord.gg/xveESFj</a>
+<br>Forums: <a href='http://forum.freeso.org'>http://forum.freeso.org</a>
+<br>Twitter: <a href='http://twitter.com/FreeSOGame'>http://twitter.com/FreeSOGame</a>
+<br>
+<br>
+<strong>Learn how to get started:</strong>
+<br>Check out TSOMania's guide at <a href="http://www.tsomania.net/gameguides/getting_started.php">TSOMania.net</a>.

server/FSO.Server.Api.Core/MailTemplates/MailRegistrationToken.html

@@ -0,0 +1,11 @@
+<strong>You are almost here...</strong>
+<br>One last step! Verify your email address:
+<br><a href='%confirmation_url%'>Click here finish your registration</a>. The link will expire in %expires%.
+<br>Just in case, your token is: %token%.
+<br />
+<br>Official Discord: <a href='https://discord.gg/xveESFj'>https://discord.gg/xveESFj</a>
+<br>Forums: <a href='http://forum.freeso.org'>http://forum.freeso.org</a>
+<br>Twitter: <a href='http://twitter.com/FreeSOGame'>http://twitter.com/FreeSOGame</a>
+<br>
+<br><strong>Download the FreeSO Installer</strong>
+<br>Get the installer from <a href='http://beta.freeso.org'>FreeSO.org</a>. After confirming your account by clicking the link above, you will be able to create an account and login.

server/FSO.Server.Api.Core/MailTemplates/MailUnban.html

@@ -0,0 +1 @@
+<!-- To-do -->

server/FSO.Server.Api.Core/Models/EventCreateModel.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+
+namespace FSO.Server.Api.Core.Models
+{
+    public class EventCreateModel
+    {
+        public string title;
+        public string description;
+        public DateTime start_day;
+        public DateTime end_day;
+        public string type;
+        public int value;
+        public int value2;
+        public string mail_subject;
+        public string mail_message;
+        public int mail_sender;
+        public string mail_sender_name;
+    }
+
+    public class PresetCreateModel
+    {
+        public string name;
+        public string description;
+        public int flags;
+        public List<PresetItemModel> items;
+    }
+
+    public class PresetItemModel
+    {
+        public string tuning_type;
+        public int tuning_table;
+        public int tuning_index;
+        public float value;
+    }
+}

server/FSO.Server.Api.Core/Models/FSOUpdateManifest.cs

@@ -0,0 +1,10 @@
+using FSO.Files.Utils;
+using System.Collections.Generic;
+
+namespace FSO.Server.Api.Core.Models
+{
+    public class FSOUpdateManifest {
+        public string Version;
+        public List<FileDiff> Diffs;
+    }
+}

server/FSO.Server.Api.Core/Models/UpdateCreateModel.cs

@@ -0,0 +1,14 @@
+namespace FSO.Server.Api.Core.Models
+{
+    public class UpdateCreateModel
+    {
+        public int branchID;
+        public uint scheduledEpoch;
+        public string catalog;
+
+        public bool contentOnly;
+        public bool includeMonogameDelta;
+        public bool disableIncremental;
+        public bool minorVersion;
+    }
+}

server/FSO.Server.Api.Core/Models/UpdateGenerationStatus.cs

@@ -0,0 +1,69 @@
+using FSO.Server.Database.DA.Updates;
+
+namespace FSO.Server.Api.Core.Models
+{
+    public class UpdateGenerationStatus
+    {
+        public int TaskID;
+        public UpdateCreateModel Request;
+        public UpdateGenerationStatusCode Code;
+        public float EstimatedProgress;
+
+        public DbUpdate Result;
+        public string Failure;
+
+        public UpdateGenerationStatus(int taskID, UpdateCreateModel request)
+        {
+            TaskID = taskID;
+            Request = request;
+        }
+
+        public void UpdateStatus(UpdateGenerationStatusCode code, float progress)
+        {
+            Code = code;
+            EstimatedProgress = progress;
+        }
+
+        public void UpdateStatus(UpdateGenerationStatusCode code)
+        {
+            UpdateStatus(code, ((float)code - 1) / ((float)UpdateGenerationStatusCode.SUCCESS - 1));
+        }
+
+        public void SetResult(DbUpdate result)
+        {
+            UpdateStatus(UpdateGenerationStatusCode.SUCCESS);
+            Result = result;
+        }
+
+        public void SetFailure(string failure)
+        {
+            UpdateStatus(UpdateGenerationStatusCode.FAILURE, 0);
+            Failure = failure;
+        }
+    }
+
+    public enum UpdateGenerationStatusCode
+    {
+        FAILURE = 0,
+
+        PREPARING = 1,
+        DOWNLOADING_CLIENT,
+        DOWNLOADING_SERVER,
+        DOWNLOADING_CLIENT_ADDON,
+        DOWNLOADING_SERVER_ADDON,
+        EXTRACTING_CLIENT,
+        EXTRACTING_CLIENT_ADDON,
+        BUILDING_DIFF,
+        BUILDING_INCREMENTAL_UPDATE,
+        BUILDING_CLIENT,
+        PUBLISHING_CLIENT,
+
+        EXTRACTING_SERVER,
+        EXTRACTING_SERVER_ADDON,
+        BUILDING_SERVER,
+        PUBLISHING_SERVER,
+
+        SCHEDULING_UPDATE,
+        SUCCESS
+    }
+}

server/FSO.Server.Api.Core/Program.cs

@@ -0,0 +1,53 @@
+using FSO.Server.Common;
+using Microsoft.AspNetCore;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace FSO.Server.Api.Core
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            var host = CreateWebHostBuilder(args).Build();
+            host.Run();
+        }
+
+        public static IAPILifetime RunAsync(string[] args)
+        {
+            var host = CreateWebHostBuilder(args).Build();
+            var lifetime = new APIControl((IApplicationLifetime)host.Services.GetService(typeof(IApplicationLifetime)));
+            host.Start();
+            return lifetime;
+        }
+
+        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+            WebHost.CreateDefaultBuilder(args)
+                .UseUrls(args[0])
+                .ConfigureLogging(x =>
+                {
+                    x.SetMinimumLevel(LogLevel.None);
+                })
+                .UseKestrel(options =>
+                {
+                    options.Limits.MaxRequestBodySize = 500000000;
+                })
+                .SuppressStatusMessages(true)
+                .UseStartup<Startup>();
+    }
+
+    public class APIControl : IAPILifetime
+    {
+        private IApplicationLifetime Lifetime;
+        
+        public APIControl(IApplicationLifetime lifetime)
+        {
+            Lifetime = lifetime;
+        }
+
+        public void Stop()
+        {
+            Lifetime.StopApplication();
+        }
+    }
+}

server/FSO.Server.Api.Core/Properties/launchSettings.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:61113",
+      "sslPort": 44333
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "api/values",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "FSO.Server.Api.Core": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "api/values",
+      "applicationUrl": "https://localhost:5001;http://localhost:5000",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

server/FSO.Server.Api.Core/Services/AWSUpdateUploader.cs

@@ -0,0 +1,54 @@
+using Amazon;
+using Amazon.Runtime;
+using Amazon.S3;
+using Amazon.S3.Model;
+using FSO.Server.Common.Config;
+using System;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace FSO.Server.Api.Core.Services
+{
+    public class AWSUpdateUploader : IUpdateUploader
+    {
+        private AWSConfig Config;
+        public AWSUpdateUploader(AWSConfig config)
+        {
+            Config = config;
+        }
+
+        public async Task<string> UploadFile(string destPath, string fileName, string groupName)
+        {
+            var region = Config.Region;
+            var bucket = Config.Bucket;
+            var s3config = new AmazonS3Config()
+            {
+                RegionEndpoint = RegionEndpoint.GetBySystemName(region),
+                Timeout = new TimeSpan(1, 0, 0),
+                ReadWriteTimeout = new TimeSpan(1, 0, 0),
+                MaxErrorRetry = 512
+            };
+
+            using (var aws = new AmazonS3Client(new BasicAWSCredentials(Config.AccessKeyID, Config.SecretAccessKey), s3config))
+            {
+                PutObjectRequest request = new PutObjectRequest()
+                {
+                    InputStream = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite),
+                    BucketName = bucket,
+                    CannedACL = S3CannedACL.PublicRead,
+                    Key = destPath
+                };
+                PutObjectResponse response = await aws.PutObjectAsync(request);
+
+                if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
+                {
+                    return $"https://s3.{region}.amazonaws.com/{bucket}/" + destPath;
+                }
+                else
+                {
+                    throw new Exception("Uploading file " + destPath + " failed with code " + response.HttpStatusCode + "!");
+                }
+            }
+        }
+    }
+}

server/FSO.Server.Api.Core/Services/GenerateUpdateService.cs

@@ -0,0 +1,324 @@
+using FSO.Server.Api.Core.Models;
+using FSO.Server.Database.DA.Updates;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using FSO.Files.Utils;
+using FSO.Server.Common;
+using System.Diagnostics;
+
+namespace FSO.Server.Api.Core.Services
+{
+    public class GenerateUpdateService
+    {
+        private static GenerateUpdateService _INSTANCE;
+        public static GenerateUpdateService INSTANCE
+        {
+            get
+            {
+                if (_INSTANCE == null) _INSTANCE = new GenerateUpdateService();
+                return _INSTANCE;
+            }
+        }
+
+        private int LastTaskID = 0;
+        public Dictionary<int, UpdateGenerationStatus> Tasks = new Dictionary<int, UpdateGenerationStatus>();
+
+        public UpdateGenerationStatus GetTask(int id)
+        {
+            UpdateGenerationStatus result;
+            lock (Tasks)
+            {
+                if (!Tasks.TryGetValue(id, out result)) return null;
+            }
+            return result;
+        }
+
+        public UpdateGenerationStatus CreateTask(UpdateCreateModel request)
+        {
+            UpdateGenerationStatus task;
+            lock (Tasks)
+            {
+                task = new UpdateGenerationStatus(++LastTaskID, request);
+                Tasks[LastTaskID] = task;
+            }
+            Task.Run(() => BuildUpdate(task));
+            return task;
+        }
+
+        private void Exec(string cmd)
+        {
+            var escapedArgs = cmd.Replace("\"", "\\\"");
+
+            var process = new Process
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    RedirectStandardOutput = true,
+                    UseShellExecute = false,
+                    CreateNoWindow = true,
+                    WindowStyle = ProcessWindowStyle.Hidden,
+                    FileName = "/bin/sh",
+                    Arguments = $"-c \"{escapedArgs}\""
+                }
+            };
+
+            process.Start();
+            process.WaitForExit();
+        }
+
+        private void ClearFolderPermissions(string folder)
+        {
+            if (Environment.OSVersion.Platform == PlatformID.Unix)
+                Exec($"chmod -R 777 {folder}");
+        }
+
+        private string GetZipFolder(string path)
+        {
+            var directories = Directory.GetDirectories(path);
+            if (directories.Length != 1) return path;
+            var files = Directory.GetFiles(path);
+            if (files.Length != 0) return path;
+            return directories[0];
+        }
+
+        public async Task BuildUpdate(UpdateGenerationStatus status)
+        {
+            var request = status.Request;
+            var api = Api.INSTANCE;
+
+            try
+            {
+                status.UpdateStatus(UpdateGenerationStatusCode.PREPARING);
+                using (var da = api.DAFactory.Get())
+                {
+                    var baseUpdateKey = "updates/";
+                    var branch = da.Updates.GetBranch(status.Request.branchID);
+
+                    //reserve update id. may cause race condition, but only one person can update anyways.
+                    if (request.minorVersion) ++branch.minor_version_number;
+                    else
+                    {
+                        ++branch.last_version_number;
+                        branch.minor_version_number = 0;
+                    }
+                    var updateID = branch.last_version_number;
+                    var minorChar = (branch.minor_version_number == 0) ? "" : ((char)('a' + (branch.minor_version_number - 1))).ToString();
+                    var versionName = branch.version_format.Replace("#", updateID.ToString()).Replace("@", minorChar);
+                    var versionText = versionName;
+
+                    var result = new DbUpdate()
+                    {
+                        addon_id = branch.addon_id,
+                        branch_id = branch.branch_id,
+                        date = DateTime.UtcNow,
+                        version_name = versionName,
+                        deploy_after = Epoch.ToDate(status.Request.scheduledEpoch)
+                    };
+
+                    versionName = versionName.Replace('/', '-');
+
+                    var client = new WebClient();
+                    //fetch artifacts
+                    //http://servo.freeso.org/guestAuth/repository/download/FreeSO_TsoClient/.lastSuccessful/client-<>.zip
+                    //http://servo.freeso.org/guestAuth/repository/download/FreeSO_TsoClient/.lastSuccessful/server-<>.zip
+
+                    int updateWorkID = status.TaskID;
+
+                    var updateDir = "updateTemp/" + updateWorkID + "/";
+                    try
+                    {
+                        Directory.Delete(updateDir, true);
+                    }
+                    catch (Exception) { }
+                    Directory.CreateDirectory(updateDir);
+                    Directory.CreateDirectory(updateDir + "client/");
+                    Directory.CreateDirectory(updateDir + "server/");
+
+                    string clientArti = null;
+                    string serverArti = null;
+                    if (branch.base_build_url != null)
+                    {
+                        status.UpdateStatus(UpdateGenerationStatusCode.DOWNLOADING_CLIENT);
+                        await client.DownloadFileTaskAsync(new Uri(branch.base_build_url), updateDir + "client.zip");
+                        clientArti = updateDir + "client.zip";
+                    }
+                    if (branch.base_server_build_url != null)
+                    {
+                        status.UpdateStatus(UpdateGenerationStatusCode.DOWNLOADING_SERVER);
+                        await client.DownloadFileTaskAsync(new Uri(branch.base_server_build_url), updateDir + "server.zip");
+                        serverArti = updateDir + "server.zip";
+                    }
+
+                    string clientAddon = null;
+                    string serverAddon = null;
+
+                    if (branch.addon_id != null)
+                    {
+                        var addon = da.Updates.GetAddon(branch.addon_id.Value);
+                        if (addon.addon_zip_url != null)
+                        {
+                            status.UpdateStatus(UpdateGenerationStatusCode.DOWNLOADING_CLIENT_ADDON);
+                            await client.DownloadFileTaskAsync(new Uri(addon.addon_zip_url), updateDir + "clientAddon.zip");
+                            clientAddon = updateDir + "clientAddon.zip";
+                        }
+                        if (addon.server_zip_url != null)
+                        {
+                            status.UpdateStatus(UpdateGenerationStatusCode.DOWNLOADING_SERVER_ADDON);
+                            await client.DownloadFileTaskAsync(new Uri(addon.addon_zip_url), updateDir + "serverAddon.zip");
+                            serverAddon = updateDir + "serverAddon.zip";
+                        }
+                        else
+                        {
+                            serverAddon = clientAddon;
+                        }
+                    }
+
+                    //last client update.
+                    var previousUpdate = (branch.current_dist_id == null) ? null : da.Updates.GetUpdate(branch.current_dist_id.Value);
+
+                    //all files downloaded. build the folders.
+                    //extract the artifact and then our artifact over it.
+                    if (clientArti != null)
+                    {
+                        var clientPath = updateDir + "client/";
+                        status.UpdateStatus(UpdateGenerationStatusCode.EXTRACTING_CLIENT);
+                        var clientZip = ZipFile.Open(clientArti, ZipArchiveMode.Read);
+                        clientZip.ExtractToDirectory(clientPath, true);
+                        clientZip.Dispose();
+                        File.Delete(clientArti);
+                        clientPath = GetZipFolder(clientPath);
+
+                        if (clientAddon != null)
+                        {
+                            status.UpdateStatus(UpdateGenerationStatusCode.EXTRACTING_CLIENT_ADDON);
+                            var addonZip = ZipFile.Open(clientAddon, ZipArchiveMode.Read);
+                            addonZip.ExtractToDirectory(clientPath, true);
+                            addonZip.Dispose();
+                            if (clientAddon != serverAddon) File.Delete(clientAddon);
+                        }
+                        //emit version number
+                        await System.IO.File.WriteAllTextAsync(Path.Combine(clientPath, "version.txt"), versionText);
+                        if (request.catalog != null)
+                        {
+                            await System.IO.File.WriteAllTextAsync(Path.Combine(clientPath, "Content/Objects/catalog_downloads.xml"), request.catalog);
+                        }
+
+                        string diffZip = null;
+                        FSOUpdateManifest manifest = null;
+
+                        status.UpdateStatus(UpdateGenerationStatusCode.BUILDING_DIFF);
+                        if (previousUpdate != null || request.disableIncremental)
+                        {
+                            result.last_update_id = previousUpdate.update_id;
+                            //calculate difference, generate an incremental update manifest + zip
+                            var prevFile = updateDir + "prev.zip";
+                            await client.DownloadFileTaskAsync(new Uri(previousUpdate.full_zip), updateDir + "prev.zip");
+                            var prevZip = ZipFile.Open(prevFile, ZipArchiveMode.Read);
+                            prevZip.ExtractToDirectory(updateDir + "prev/", true);
+                            prevZip.Dispose();
+                            File.Delete(updateDir + "prev.zip");
+
+                            var diffs = DiffGenerator.GetDiffs(Path.GetFullPath(updateDir + "prev/"), Path.GetFullPath(clientPath));
+
+                            status.UpdateStatus(UpdateGenerationStatusCode.BUILDING_INCREMENTAL_UPDATE);
+                            var toZip = diffs.Where(x => x.DiffType == FileDiffType.Add || x.DiffType == FileDiffType.Modify);
+                            if (request.contentOnly) toZip = toZip.Where(x => x.Path.Replace('\\', '/').TrimStart('/').StartsWith("Content"));
+                            if (!request.includeMonogameDelta) toZip = toZip.Where(x => !x.Path.Replace('\\', '/').TrimStart('/').StartsWith("Monogame"));
+                            //build diff folder
+                            Directory.CreateDirectory(updateDir + "diff/");
+                            foreach (var diff in toZip)
+                            {
+                                Directory.CreateDirectory(Path.GetDirectoryName(Path.Combine(updateDir + "diff/", diff.Path)));
+                                System.IO.File.Copy(Path.Combine(clientPath, diff.Path), Path.Combine(updateDir + "diff/", diff.Path));
+                            }
+                            diffZip = updateDir + "diffResult.zip";
+                            ClearFolderPermissions(updateDir + "diff/");
+                            ZipFile.CreateFromDirectory(updateDir + "diff/", diffZip, CompressionLevel.Optimal, false);
+                            Directory.Delete(updateDir + "diff/", true);
+                            manifest = new FSOUpdateManifest() { Diffs = diffs };
+
+                            Directory.Delete(updateDir + "prev/", true);
+                        }
+                        else
+                        {
+                            if (request.contentOnly) throw new Exception("Invalid request - you cannot make a content only update with no delta.");
+                            //full update only. generate simple manifest that contains all files (added)
+                            manifest = new FSOUpdateManifest() { Diffs = new List<FileDiff>() };
+                        }
+
+                        //pack full client
+                        if (!request.contentOnly)
+                        {
+                            status.UpdateStatus(UpdateGenerationStatusCode.BUILDING_CLIENT);
+                            var finalClientZip = updateDir + "clientResult.zip";
+                            ClearFolderPermissions(clientPath);
+                            ZipFile.CreateFromDirectory(clientPath, finalClientZip, CompressionLevel.Optimal, false);
+                            Directory.Delete(updateDir + "client/", true);
+
+                            status.UpdateStatus(UpdateGenerationStatusCode.PUBLISHING_CLIENT);
+                            result.full_zip = await Api.INSTANCE.UpdateUploaderClient.UploadFile($"{baseUpdateKey}client-{versionName}.zip", finalClientZip, versionName);
+                        }
+                        status.UpdateStatus(UpdateGenerationStatusCode.PUBLISHING_CLIENT);
+                        if (diffZip != null)
+                        {
+                            result.incremental_zip = await Api.INSTANCE.UpdateUploaderClient.UploadFile($"{baseUpdateKey}incremental-{versionName}.zip", diffZip, versionName);
+                        }
+                        await System.IO.File.WriteAllTextAsync(updateDir + "manifest.json", Newtonsoft.Json.JsonConvert.SerializeObject(manifest));
+                        result.manifest_url = await Api.INSTANCE.UpdateUploaderClient.UploadFile($"{baseUpdateKey}{versionName}.json", updateDir + "manifest.json", versionName);
+                    }
+
+                    if (serverArti != null && !request.contentOnly)
+                    {
+                        var serverPath = updateDir + "server/";
+                        status.UpdateStatus(UpdateGenerationStatusCode.EXTRACTING_SERVER);
+                        var serverZip = ZipFile.Open(serverArti, ZipArchiveMode.Read);
+                        serverZip.ExtractToDirectory(serverPath, true);
+                        serverZip.Dispose();
+                        File.Delete(serverArti);
+                        serverPath = GetZipFolder(serverPath);
+
+                        if (serverAddon != null)
+                        {
+                            status.UpdateStatus(UpdateGenerationStatusCode.EXTRACTING_SERVER_ADDON);
+                            var addonZip = ZipFile.Open(serverAddon, ZipArchiveMode.Read);
+                            addonZip.ExtractToDirectory(serverPath, true);
+                            addonZip.Dispose();
+                            File.Delete(serverAddon);
+                        }
+                        //emit version number
+                        await System.IO.File.WriteAllTextAsync(Path.Combine(serverPath, "version.txt"), versionText);
+                        if (request.catalog != null)
+                        {
+                            await System.IO.File.WriteAllTextAsync(Path.Combine(serverPath, "Content/Objects/catalog_downloads.xml"), request.catalog);
+                        }
+
+                        status.UpdateStatus(UpdateGenerationStatusCode.BUILDING_SERVER);
+                        var finalServerZip = updateDir + "serverResult.zip";
+                        ClearFolderPermissions(serverPath);
+                        ZipFile.CreateFromDirectory(serverPath, finalServerZip, CompressionLevel.Optimal, false);
+                        Directory.Delete(updateDir + "server/", true);
+
+                        status.UpdateStatus(UpdateGenerationStatusCode.PUBLISHING_SERVER);
+                        result.server_zip = await Api.INSTANCE.UpdateUploader.UploadFile($"{baseUpdateKey}server-{versionName}.zip", finalServerZip, versionName);
+                    } else
+                    {
+                        result.server_zip = result.incremental_zip; //same as client, as server uses same content.
+                    }
+
+                    status.UpdateStatus(UpdateGenerationStatusCode.SCHEDULING_UPDATE);
+                    var finalID = da.Updates.AddUpdate(result);
+                    da.Updates.UpdateBranchLatest(branch.branch_id, branch.last_version_number, branch.minor_version_number);
+                    status.SetResult(result);
+                }
+            } catch (Exception e)
+            {
+                status.SetFailure("Update could not be completed." + e.ToString());
+            }
+        }
+    }
+}

server/FSO.Server.Api.Core/Services/GithubUpdateUploader.cs

@@ -0,0 +1,61 @@
+using FSO.Server.Common.Config;
+using Octokit;
+using Octokit.Internal;
+using System;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace FSO.Server.Api.Core.Services
+{
+    public class GithubUpdateUploader : IUpdateUploader
+    {
+        private GithubConfig Config;
+
+        private static string Description = "This is an automated client release produced by the master FreeSO server. " +
+            "These releases match up with a branch on GitHub, but with some addon content such as a custom catalog and splash. " +
+            "It can be downloaded and installed directly, but it is better to do so through the game's launcher/updater. \n\n" +
+            "The incremental update is applied by simply extracting the zip over the previous version of the game " +
+            "(though the updater still affords extra validation here)";
+
+        public GithubUpdateUploader(GithubConfig config)
+        {
+            Config = config;
+        }
+
+        public async Task<string> UploadFile(string destPath, string fileName, string groupName)
+        {
+            destPath = Path.GetFileName(destPath);
+            var credentials = new InMemoryCredentialStore(new Credentials(Config.AccessToken));
+
+            var client = new GitHubClient(new ProductHeaderValue(Config.AppName), credentials);
+
+            Release release;
+            try
+            {
+                release = await client.Repository.Release.Get(Config.User, Config.Repository, groupName);
+            }
+            catch (Exception)
+            {
+                release = null;
+            }
+            if (release == null) {
+                var newRel = new NewRelease(groupName);
+                newRel.Body = Description;
+                release = await client.Repository.Release.Create(Config.User, Config.Repository, newRel);
+            }
+
+            using (var file = File.Open(fileName, System.IO.FileMode.Open, FileAccess.Read, FileShare.Read)) {
+                try
+                {
+                    var asset = await client.Repository.Release.UploadAsset(release, new ReleaseAssetUpload(destPath, "application/zip", file, null));
+                    return asset.BrowserDownloadUrl;
+                } catch (Exception e)
+                {
+                    //last time i tried, it mysteriously failed here but the file was uploaded :thinking:
+                    Console.WriteLine($"!! Upload request for {destPath} failed, check it actually succeeded !! \n" + e.ToString());
+                    return $"https://github.com/{Config.User}/{Config.Repository}/releases/download/{groupName}/{destPath}";
+                }
+            }
+        }
+    }
+}

server/FSO.Server.Api.Core/Services/IUpdateUploader.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace FSO.Server.Api.Core.Services
+{
+    public interface IUpdateUploader
+    {
+        Task<string> UploadFile(string destPath, string fileName, string groupName);
+    }
+}

server/FSO.Server.Api.Core/Startup.cs

@@ -0,0 +1,63 @@
+using FSO.Server.Common;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace FSO.Server.Api.Core
+{
+    public class Startup : IAPILifetime
+    {
+        public IApplicationLifetime AppLifetime;
+
+        public Startup(IConfiguration configuration)
+        {
+            Configuration = configuration;
+        }
+
+        public IConfiguration Configuration { get; }
+
+        // This method gets called by the runtime. Use this method to add services to the container.
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddCors(options =>
+            {
+               options.AddDefaultPolicy(
+                   builder =>
+                   {
+
+                       builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader().WithExposedHeaders("content-disposition");
+                   });
+
+                options.AddPolicy("AdminAppPolicy",
+                    builder =>
+                    {
+                        builder.WithOrigins("https://freeso.org", "http://localhost:8080").AllowAnyMethod().AllowAnyHeader().AllowCredentials().WithExposedHeaders("content-disposition");
+                    });
+            }).AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IHostingEnvironment env, IApplicationLifetime appLifetime)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+            else
+            {
+                app.UseHsts();
+            }
+            app.UseCors();
+            //app.UseHttpsRedirection();
+            app.UseMvc();
+            AppLifetime = appLifetime;
+        }
+
+        public void Stop()
+        {
+            AppLifetime.StopApplication();
+        }
+    }
+}

server/FSO.Server.Api.Core/Utils/ApiMail.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Mail;
+
+namespace FSO.Server.Api.Core.Utils
+{
+    /// <summary>
+    /// Used to mail our users.
+    /// Could be more useful in the future when out of Beta.
+    /// </summary>
+    public class ApiMail
+    {
+        string subject;
+        string template;
+        Dictionary<string, string> strings;
+
+        public ApiMail(string template)
+        {
+            this.template = template;
+            this.strings = new Dictionary<string, string>();
+        }
+
+        public void AddString(string key, string value)
+        {
+            strings.Add(key, value);
+        }
+
+        private string ComposeBody(Dictionary<string, string> strings)
+        {
+            string baseTemplate = File.ReadAllText("./MailTemplates/MailBase.html");
+            string content = File.ReadAllText("./MailTemplates/" + template + ".html");
+
+            foreach (KeyValuePair<string, string> entry in strings)
+            {
+                content = content.Replace("%" + entry.Key + "%", entry.Value);
+            }
+
+            strings = new Dictionary<string, string>();
+            return baseTemplate.Replace("%content%", content);
+        }
+
+        public bool Send(string to, string subject)
+        {
+            Api api = Api.INSTANCE;
+
+            if(api.Config.SmtpEnabled)
+            {
+                try
+                {
+                    MailMessage message = new MailMessage();
+                    message.From = new MailAddress(api.Config.SmtpUser, "FreeSO Staff");
+                    message.To.Add(to);
+                    message.Subject = subject;
+                    message.IsBodyHtml = true;
+                    message.Body = ComposeBody(strings);
+
+                    SmtpClient client = new SmtpClient();
+                    client.UseDefaultCredentials = true;
+
+                    client.Host = api.Config.SmtpHost;
+                    client.Port = api.Config.SmtpPort;
+                    client.EnableSsl = true;
+                    client.Credentials = new System.Net.NetworkCredential(api.Config.SmtpUser, api.Config.SmtpPassword); 
+
+                    // Send async
+                    client.SendMailAsync(message);
+
+                    return true;
+                } catch(Exception e) {
+                    return false;
+                }  
+            }
+            return false;
+        }
+    }
+}

server/FSO.Server.Api.Core/Utils/ApiResponse.cs

@@ -0,0 +1,78 @@
+using FSO.Common.Utils;
+using FSO.Server.Database.DA.Utils;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Net;
+using System.Xml;
+
+namespace FSO.Server.Api.Core.Utils
+{
+    public class ApiResponse
+    {
+        public static IActionResult Plain(HttpStatusCode code, string text)
+        {
+            return new ContentResult
+            {
+                StatusCode = (int)code,
+                Content = text,
+                ContentType = "text/plain"
+            };
+        }
+
+        public static IActionResult Json(HttpStatusCode code, object obj)
+        {
+            return new ContentResult
+            {
+                StatusCode = (int)code,
+                Content = Newtonsoft.Json.JsonConvert.SerializeObject(obj),
+                ContentType = "application/json"
+            };
+        }
+
+        public static IActionResult PagedList<T>(HttpRequest request, HttpStatusCode code, PagedList<T> list)
+        {
+            request.HttpContext.Response.Headers.Add("X-Total-Count", list.Total.ToString());
+            request.HttpContext.Response.Headers.Add("X-Offset", list.Offset.ToString());
+
+            return new ContentResult
+            {
+                StatusCode = (int)code,
+                Content = Newtonsoft.Json.JsonConvert.SerializeObject(list),
+                ContentType = "application/json"
+            };
+        }
+
+        public static IActionResult Xml(HttpStatusCode code, IXMLEntity xml)
+        {
+            var doc = new XmlDocument();
+            var firstChild = xml.Serialize(doc);
+            doc.AppendChild(firstChild);
+
+            return new ContentResult
+            {
+                StatusCode = (int)code,
+                Content = doc.OuterXml,
+                ContentType = "text/xml"
+            };
+        }
+
+        public static Func<IActionResult> XmlFuture(HttpStatusCode code, IXMLEntity xml)
+        {
+            var doc = new XmlDocument();
+            var firstChild = xml.Serialize(doc);
+            doc.AppendChild(firstChild);
+            var serialized = doc.OuterXml;
+
+            return () =>
+            {
+                return new ContentResult
+                {
+                    StatusCode = (int)code,
+                    Content = serialized,
+                    ContentType = "text/xml"
+                };
+            };
+        }
+    }
+}

server/FSO.Server.Api.Core/Utils/ApiUtils.cs

@@ -0,0 +1,35 @@
+using Microsoft.AspNetCore.Http;
+using System.Linq;
+
+namespace FSO.Server.Api.Core.Utils
+{
+    public class ApiUtils
+    {
+        private const string HttpContext = "MS_HttpContext";
+        private const string RemoteEndpointMessage =
+            "System.ServiceModel.Channels.RemoteEndpointMessageProperty";
+        private const string OwinContext = "MS_OwinContext";
+
+        public static string GetIP(HttpRequest request)
+        {
+            var api = FSO.Server.Api.Core.Api.INSTANCE;
+            if (!api.Config.UseProxy)
+            {
+                return request.HttpContext.Connection.RemoteIpAddress.ToString();
+            }
+            else
+            {
+                var ip = "127.0.0.1";
+                var xff = request.Headers["X-Forwarded-For"];
+                if (xff.Count != 0)
+                {
+                    ip = xff.First();
+                    ip = ip.Substring(ip.IndexOf(",") + 1);
+                    var last = ip.LastIndexOf(":");
+                    if (last != -1 && last < ip.Length - 5) ip = ip.Substring(0, last);
+                }
+                return ip;
+            }
+        }
+    }
+}

server/FSO.Server.Api.Core/appsettings.Development.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Debug",
+      "System": "Information",
+      "Microsoft": "Information"
+    }
+  }
+}

server/FSO.Server.Api.Core/appsettings.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}

server/FSO.Server.Api.Core/obj/Debug/netcoreapp2.2/.NETCoreApp,Version=v2.2.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v2.2", FrameworkDisplayName = ".NET Core 2.2")]

server/FSO.Server.Api.Core/obj/Debug/netcoreapp2.2/FSO.Server.Api.Core.AssemblyInfo.cs

@@ -0,0 +1,22 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: System.Reflection.AssemblyCompanyAttribute("FSO.Server.Api.Core")]
+[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+f12ba1502b1a207b2b7e131c8ed38d8d4ef33d1e")]
+[assembly: System.Reflection.AssemblyProductAttribute("FSO.Server.Api.Core")]
+[assembly: System.Reflection.AssemblyTitleAttribute("FSO.Server.Api.Core")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
+
+// Generated by the MSBuild WriteCodeFragment class.
+

server/FSO.Server.Api.Core/obj/Debug/netcoreapp2.2/FSO.Server.Api.Core.AssemblyInfoInputs.cache

@@ -0,0 +1 @@
+56295aa1e4d64bef744bb30e9641d816d4a2f240e548daea26ca3acc11acdbfc

server/FSO.Server.Api.Core/obj/Debug/netcoreapp2.2/FSO.Server.Api.Core.GeneratedMSBuildEditorConfig.editorconfig

@@ -0,0 +1,5 @@
+is_global = true
+build_property.RootNamespace = FSO.Server.Api.Core
+build_property.ProjectDir = /Volumes/TheD/Projects/ztso/server/FSO.Server.Api.Core/
+build_property.EnableComHosting = 
+build_property.EnableGeneratedComInterfaceComImportInterop = 

server/FSO.Server.Api.Core/obj/Debug/netcoreapp2.2/FSO.Server.Api.Core.RazorAssemblyInfo.cache

@@ -0,0 +1 @@
+96ad7024ec164a21bac08e2efe1079153c67c90031478db2e40a71ebb48e40d6

server/FSO.Server.Api.Core/obj/Debug/netcoreapp2.2/FSO.Server.Api.Core.RazorAssemblyInfo.cs

@@ -0,0 +1,19 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: Microsoft.AspNetCore.Mvc.ApplicationParts.RelatedAssemblyAttribute("FSO.Server.Api.Core.Views")]
+[assembly: Microsoft.AspNetCore.Razor.Hosting.RazorLanguageVersionAttribute("2.1")]
+[assembly: Microsoft.AspNetCore.Razor.Hosting.RazorConfigurationNameAttribute("MVC-2.1")]
+[assembly: Microsoft.AspNetCore.Razor.Hosting.RazorExtensionAssemblyNameAttribute("MVC-2.1", "Microsoft.AspNetCore.Mvc.Razor.Extensions")]
+
+// Generated by the MSBuild WriteCodeFragment class.
+

server/FSO.Server.Api.Core/obj/FSO.Server.Api.Core.csproj.nuget.dgspec.json

@@ -0,0 +1,267 @@
+{
+  "format": 1,
+  "restore": {
+    "/Volumes/TheD/Projects/ztso/server/FSO.Server.Api.Core/FSO.Server.Api.Core.csproj": {}
+  },
+  "projects": {
+    "/Volumes/TheD/Projects/ztso/server/FSO.Server.Api.Core/FSO.Server.Api.Core.csproj": {
+      "version": "1.0.0",
+      "restore": {
+        "projectUniqueName": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Api.Core/FSO.Server.Api.Core.csproj",
+        "projectName": "FSO.Server.Api.Core",
+        "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Api.Core/FSO.Server.Api.Core.csproj",
+        "packagesPath": "/Volumes/TheD/.nuget",
+        "outputPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Api.Core/obj/",
+        "projectStyle": "PackageReference",
+        "configFilePaths": [
+          "/Users/tonytins/.nuget/NuGet/NuGet.Config"
+        ],
+        "originalTargetFrameworks": [
+          "netcoreapp2.2"
+        ],
+        "sources": {
+          "/Volumes/TheD/.dotnet/library-packs": {},
+          "https://api.nuget.org/v3/index.json": {}
+        },
+        "frameworks": {
+          "netcoreapp2.2": {
+            "targetAlias": "netcoreapp2.2",
+            "projectReferences": {
+              "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/FSO.Server.Common.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/FSO.Server.Common.csproj"
+              },
+              "/Volumes/TheD/Projects/ztso/server/FSO.Server.Database/FSO.Server.Database.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Database/FSO.Server.Database.csproj"
+              },
+              "/Volumes/TheD/Projects/ztso/server/FSO.Server.Domain/FSO.Server.Domain.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Domain/FSO.Server.Domain.csproj"
+              },
+              "/Volumes/TheD/Projects/ztso/server/FSO.Server.Protocol/FSO.Server.Protocol.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Protocol/FSO.Server.Protocol.csproj"
+              },
+              "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj"
+              }
+            }
+          }
+        },
+        "warningProperties": {
+          "warnAsError": [
+            "NU1605"
+          ]
+        },
+        "restoreAuditProperties": {
+          "enableAudit": "true",
+          "auditLevel": "low",
+          "auditMode": "direct"
+        }
+      },
+      "frameworks": {
+        "netcoreapp2.2": {
+          "targetAlias": "netcoreapp2.2",
+          "dependencies": {
+            "AWSSDK.Core": {
+              "target": "Package",
+              "version": "[3.3.103.48, )"
+            },
+            "AWSSDK.S3": {
+              "target": "Package",
+              "version": "[3.3.104.36, )"
+            },
+            "Microsoft.AspNetCore.All": {
+              "target": "Package",
+              "version": "[2.2.7, )"
+            },
+            "Microsoft.AspNetCore.App": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[2.2.8, )",
+              "autoReferenced": true
+            },
+            "Microsoft.AspNetCore.Cors": {
+              "target": "Package",
+              "version": "[2.2.0, )"
+            },
+            "Microsoft.NETCore.App": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[2.2.8, )",
+              "autoReferenced": true
+            },
+            "Octokit": {
+              "target": "Package",
+              "version": "[0.36.0, )"
+            },
+            "System.Security.Cryptography.Algorithms": {
+              "target": "Package",
+              "version": "[4.3.1, )"
+            }
+          },
+          "imports": [
+            "net461",
+            "net462",
+            "net47",
+            "net471",
+            "net472",
+            "net48",
+            "net481"
+          ],
+          "assetTargetFallback": true,
+          "warn": true,
+          "runtimeIdentifierGraphPath": "/Volumes/TheD/.dotnet/sdk/8.0.204/RuntimeIdentifierGraph.json"
+        }
+      }
+    },
+    "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/FSO.Server.Common.csproj": {
+      "restore": {
+        "projectUniqueName": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/FSO.Server.Common.csproj",
+        "projectName": "FSO.Server.Common",
+        "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/FSO.Server.Common.csproj",
+        "packagesPath": "/Volumes/TheD/.nuget",
+        "projectStyle": "PackagesConfig",
+        "configFilePaths": [
+          "/Users/tonytins/.nuget/NuGet/NuGet.Config"
+        ],
+        "sources": {
+          "https://api.nuget.org/v3/index.json": {}
+        },
+        "frameworks": {
+          "net45": {
+            "projectReferences": {
+              "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj"
+              }
+            }
+          }
+        },
+        "packagesConfigPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/packages.config"
+      },
+      "frameworks": {
+        "net45": {}
+      }
+    },
+    "/Volumes/TheD/Projects/ztso/server/FSO.Server.Database/FSO.Server.Database.csproj": {
+      "restore": {
+        "projectUniqueName": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Database/FSO.Server.Database.csproj",
+        "projectName": "FSO.Server.Database",
+        "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Database/FSO.Server.Database.csproj",
+        "packagesPath": "/Volumes/TheD/.nuget",
+        "projectStyle": "PackagesConfig",
+        "configFilePaths": [
+          "/Users/tonytins/.nuget/NuGet/NuGet.Config"
+        ],
+        "sources": {
+          "https://api.nuget.org/v3/index.json": {}
+        },
+        "frameworks": {
+          "net45": {
+            "projectReferences": {
+              "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/FSO.Server.Common.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/FSO.Server.Common.csproj"
+              },
+              "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj"
+              }
+            }
+          }
+        },
+        "packagesConfigPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Database/packages.config"
+      },
+      "frameworks": {
+        "net45": {}
+      }
+    },
+    "/Volumes/TheD/Projects/ztso/server/FSO.Server.Domain/FSO.Server.Domain.csproj": {
+      "restore": {
+        "projectUniqueName": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Domain/FSO.Server.Domain.csproj",
+        "projectName": "FSO.Server.Domain",
+        "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Domain/FSO.Server.Domain.csproj",
+        "packagesPath": "/Volumes/TheD/.nuget",
+        "projectStyle": "PackagesConfig",
+        "configFilePaths": [
+          "/Users/tonytins/.nuget/NuGet/NuGet.Config"
+        ],
+        "sources": {
+          "https://api.nuget.org/v3/index.json": {}
+        },
+        "frameworks": {
+          "net45": {
+            "projectReferences": {
+              "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/FSO.Server.Common.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/FSO.Server.Common.csproj"
+              },
+              "/Volumes/TheD/Projects/ztso/server/FSO.Server.Database/FSO.Server.Database.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Database/FSO.Server.Database.csproj"
+              },
+              "/Volumes/TheD/Projects/ztso/server/FSO.Server.Protocol/FSO.Server.Protocol.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Protocol/FSO.Server.Protocol.csproj"
+              },
+              "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj"
+              }
+            }
+          }
+        },
+        "packagesConfigPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Domain/packages.config"
+      },
+      "frameworks": {
+        "net45": {}
+      }
+    },
+    "/Volumes/TheD/Projects/ztso/server/FSO.Server.Protocol/FSO.Server.Protocol.csproj": {
+      "restore": {
+        "projectUniqueName": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Protocol/FSO.Server.Protocol.csproj",
+        "projectName": "FSO.Server.Protocol",
+        "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Protocol/FSO.Server.Protocol.csproj",
+        "packagesPath": "/Volumes/TheD/.nuget",
+        "projectStyle": "PackagesConfig",
+        "configFilePaths": [
+          "/Users/tonytins/.nuget/NuGet/NuGet.Config"
+        ],
+        "sources": {
+          "https://api.nuget.org/v3/index.json": {}
+        },
+        "frameworks": {
+          "net45": {
+            "projectReferences": {
+              "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/FSO.Server.Common.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Common/FSO.Server.Common.csproj"
+              },
+              "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj": {
+                "projectPath": "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj"
+              }
+            }
+          }
+        },
+        "packagesConfigPath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Protocol/packages.config"
+      },
+      "frameworks": {
+        "net45": {}
+      }
+    },
+    "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj": {
+      "restore": {
+        "projectUniqueName": "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj",
+        "projectName": "FSO.Common",
+        "projectPath": "/Volumes/TheD/Projects/ztso/server/tso.common/FSO.Common.csproj",
+        "packagesPath": "/Volumes/TheD/.nuget",
+        "projectStyle": "PackagesConfig",
+        "configFilePaths": [
+          "/Users/tonytins/.nuget/NuGet/NuGet.Config"
+        ],
+        "sources": {
+          "https://api.nuget.org/v3/index.json": {}
+        },
+        "frameworks": {
+          "net45": {
+            "projectReferences": {}
+          }
+        },
+        "packagesConfigPath": "/Volumes/TheD/Projects/ztso/server/tso.common/packages.config"
+      },
+      "frameworks": {
+        "net45": {}
+      }
+    }
+  }
+}

server/FSO.Server.Api.Core/obj/FSO.Server.Api.Core.csproj.nuget.g.props

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <RestoreSuccess Condition=" '$(RestoreSuccess)' == '' ">True</RestoreSuccess>
+    <RestoreTool Condition=" '$(RestoreTool)' == '' ">NuGet</RestoreTool>
+    <ProjectAssetsFile Condition=" '$(ProjectAssetsFile)' == '' ">$(MSBuildThisFileDirectory)project.assets.json</ProjectAssetsFile>
+    <NuGetPackageRoot Condition=" '$(NuGetPackageRoot)' == '' ">/Volumes/TheD/.nuget</NuGetPackageRoot>
+    <NuGetPackageFolders Condition=" '$(NuGetPackageFolders)' == '' ">/Volumes/TheD/.nuget</NuGetPackageFolders>
+    <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
+    <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">6.9.1</NuGetToolVersion>
+  </PropertyGroup>
+  <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <SourceRoot Include="/Volumes/TheD/.nuget/" />
+  </ItemGroup>
+  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <Import Project="$(NuGetPackageRoot)/microsoft.netcore.app/2.2.8/build/netcoreapp2.2/Microsoft.NETCore.App.props" Condition="Exists('$(NuGetPackageRoot)/microsoft.netcore.app/2.2.8/build/netcoreapp2.2/Microsoft.NETCore.App.props')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.extensions.fileproviders.embedded/2.2.0/build/netstandard2.0/Microsoft.Extensions.FileProviders.Embedded.props" Condition="Exists('$(NuGetPackageRoot)/microsoft.extensions.fileproviders.embedded/2.2.0/build/netstandard2.0/Microsoft.Extensions.FileProviders.Embedded.props')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.extensions.configuration.usersecrets/2.2.0/build/netstandard2.0/Microsoft.Extensions.Configuration.UserSecrets.props" Condition="Exists('$(NuGetPackageRoot)/microsoft.extensions.configuration.usersecrets/2.2.0/build/netstandard2.0/Microsoft.Extensions.Configuration.UserSecrets.props')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.entityframeworkcore.design/2.2.6/build/netcoreapp2.0/Microsoft.EntityFrameworkCore.Design.props" Condition="Exists('$(NuGetPackageRoot)/microsoft.entityframeworkcore.design/2.2.6/build/netcoreapp2.0/Microsoft.EntityFrameworkCore.Design.props')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.aspnetcore.mvc.razor.extensions/2.2.0/build/netstandard2.0/Microsoft.AspNetCore.Mvc.Razor.Extensions.props" Condition="Exists('$(NuGetPackageRoot)/microsoft.aspnetcore.mvc.razor.extensions/2.2.0/build/netstandard2.0/Microsoft.AspNetCore.Mvc.Razor.Extensions.props')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.aspnetcore.razor.design/2.2.0/build/netstandard2.0/Microsoft.AspNetCore.Razor.Design.props" Condition="Exists('$(NuGetPackageRoot)/microsoft.aspnetcore.razor.design/2.2.0/build/netstandard2.0/Microsoft.AspNetCore.Razor.Design.props')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.aspnetcore.app/2.2.8/build/netcoreapp2.2/Microsoft.AspNetCore.App.props" Condition="Exists('$(NuGetPackageRoot)/microsoft.aspnetcore.app/2.2.8/build/netcoreapp2.2/Microsoft.AspNetCore.App.props')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.aspnetcore.all/2.2.7/build/netcoreapp2.2/Microsoft.AspNetCore.All.props" Condition="Exists('$(NuGetPackageRoot)/microsoft.aspnetcore.all/2.2.7/build/netcoreapp2.2/Microsoft.AspNetCore.All.props')" />
+  </ImportGroup>
+  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <PkgMicrosoft_EntityFrameworkCore_Tools Condition=" '$(PkgMicrosoft_EntityFrameworkCore_Tools)' == '' ">/Volumes/TheD/.nuget/microsoft.entityframeworkcore.tools/2.2.6</PkgMicrosoft_EntityFrameworkCore_Tools>
+    <PkgMicrosoft_CodeAnalysis_Analyzers Condition=" '$(PkgMicrosoft_CodeAnalysis_Analyzers)' == '' ">/Volumes/TheD/.nuget/microsoft.codeanalysis.analyzers/1.1.0</PkgMicrosoft_CodeAnalysis_Analyzers>
+    <PkgMicrosoft_AspNetCore_Razor_Design Condition=" '$(PkgMicrosoft_AspNetCore_Razor_Design)' == '' ">/Volumes/TheD/.nuget/microsoft.aspnetcore.razor.design/2.2.0</PkgMicrosoft_AspNetCore_Razor_Design>
+    <PkgAWSSDK_Core Condition=" '$(PkgAWSSDK_Core)' == '' ">/Volumes/TheD/.nuget/awssdk.core/3.3.103.48</PkgAWSSDK_Core>
+    <PkgAWSSDK_S3 Condition=" '$(PkgAWSSDK_S3)' == '' ">/Volumes/TheD/.nuget/awssdk.s3/3.3.104.36</PkgAWSSDK_S3>
+  </PropertyGroup>
+</Project>

server/FSO.Server.Api.Core/obj/FSO.Server.Api.Core.csproj.nuget.g.targets

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <Import Project="$(NuGetPackageRoot)/netstandard.library/2.0.3/build/netstandard2.0/NETStandard.Library.targets" Condition="Exists('$(NuGetPackageRoot)/netstandard.library/2.0.3/build/netstandard2.0/NETStandard.Library.targets')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.netcore.app/2.2.8/build/netcoreapp2.2/Microsoft.NETCore.App.targets" Condition="Exists('$(NuGetPackageRoot)/microsoft.netcore.app/2.2.8/build/netcoreapp2.2/Microsoft.NETCore.App.targets')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.extensions.fileproviders.embedded/2.2.0/build/netstandard2.0/Microsoft.Extensions.FileProviders.Embedded.targets" Condition="Exists('$(NuGetPackageRoot)/microsoft.extensions.fileproviders.embedded/2.2.0/build/netstandard2.0/Microsoft.Extensions.FileProviders.Embedded.targets')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.extensions.configuration.usersecrets/2.2.0/build/netstandard2.0/Microsoft.Extensions.Configuration.UserSecrets.targets" Condition="Exists('$(NuGetPackageRoot)/microsoft.extensions.configuration.usersecrets/2.2.0/build/netstandard2.0/Microsoft.Extensions.Configuration.UserSecrets.targets')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.aspnetcore.mvc.razor.extensions/2.2.0/build/netstandard2.0/Microsoft.AspNetCore.Mvc.Razor.Extensions.targets" Condition="Exists('$(NuGetPackageRoot)/microsoft.aspnetcore.mvc.razor.extensions/2.2.0/build/netstandard2.0/Microsoft.AspNetCore.Mvc.Razor.Extensions.targets')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.aspnetcore.server.iisintegration/2.2.1/build/netstandard2.0/Microsoft.AspNetCore.Server.IISIntegration.targets" Condition="Exists('$(NuGetPackageRoot)/microsoft.aspnetcore.server.iisintegration/2.2.1/build/netstandard2.0/Microsoft.AspNetCore.Server.IISIntegration.targets')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.aspnetcore.server.iis/2.2.6/build/netstandard2.0/Microsoft.AspNetCore.Server.IIS.targets" Condition="Exists('$(NuGetPackageRoot)/microsoft.aspnetcore.server.iis/2.2.6/build/netstandard2.0/Microsoft.AspNetCore.Server.IIS.targets')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.aspnetcore.mvc.razor.viewcompilation/2.2.0/build/netstandard2.0/Microsoft.AspNetCore.Mvc.Razor.ViewCompilation.targets" Condition="Exists('$(NuGetPackageRoot)/microsoft.aspnetcore.mvc.razor.viewcompilation/2.2.0/build/netstandard2.0/Microsoft.AspNetCore.Mvc.Razor.ViewCompilation.targets')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.aspnetcore.app/2.2.8/build/netcoreapp2.2/Microsoft.AspNetCore.App.targets" Condition="Exists('$(NuGetPackageRoot)/microsoft.aspnetcore.app/2.2.8/build/netcoreapp2.2/Microsoft.AspNetCore.App.targets')" />
+    <Import Project="$(NuGetPackageRoot)/microsoft.aspnetcore.all/2.2.7/build/netcoreapp2.2/Microsoft.AspNetCore.All.targets" Condition="Exists('$(NuGetPackageRoot)/microsoft.aspnetcore.all/2.2.7/build/netcoreapp2.2/Microsoft.AspNetCore.All.targets')" />
+  </ImportGroup>
+</Project>

server/FSO.Server.Api.Core/obj/project.nuget.cache

@@ -0,0 +1,343 @@
+{
+  "version": 2,
+  "dgSpecHash": "O9uTcc8ul7R5Oy7wU0RviTvK+nfjiri5q/zad3hfpvfdHyjPko5E7PeIbBSDiQiPyuONvNRmcuzEhHPbXoSo6Q==",
+  "success": true,
+  "projectFilePath": "/Volumes/TheD/Projects/ztso/server/FSO.Server.Api.Core/FSO.Server.Api.Core.csproj",
+  "expectedPackageFiles": [
+    "/Volumes/TheD/.nuget/awssdk.core/3.3.103.48/awssdk.core.3.3.103.48.nupkg.sha512",
+    "/Volumes/TheD/.nuget/awssdk.s3/3.3.104.36/awssdk.s3.3.3.104.36.nupkg.sha512",
+    "/Volumes/TheD/.nuget/libuv/1.10.0/libuv.1.10.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/messagepack/1.7.3.7/messagepack.1.7.3.7.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.applicationinsights/2.4.0/microsoft.applicationinsights.2.4.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.applicationinsights.aspnetcore/2.1.1/microsoft.applicationinsights.aspnetcore.2.1.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.applicationinsights.dependencycollector/2.4.1/microsoft.applicationinsights.dependencycollector.2.4.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnet.webapi.client/5.2.6/microsoft.aspnet.webapi.client.5.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore/2.2.0/microsoft.aspnetcore.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.all/2.2.7/microsoft.aspnetcore.all.2.2.7.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.antiforgery/2.2.0/microsoft.aspnetcore.antiforgery.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.app/2.2.8/microsoft.aspnetcore.app.2.2.8.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.applicationinsights.hostingstartup/2.2.0/microsoft.aspnetcore.applicationinsights.hostingstartup.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication/2.2.0/microsoft.aspnetcore.authentication.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication.abstractions/2.2.0/microsoft.aspnetcore.authentication.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication.cookies/2.2.0/microsoft.aspnetcore.authentication.cookies.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication.core/2.2.0/microsoft.aspnetcore.authentication.core.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication.facebook/2.2.0/microsoft.aspnetcore.authentication.facebook.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication.google/2.2.2/microsoft.aspnetcore.authentication.google.2.2.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication.jwtbearer/2.2.0/microsoft.aspnetcore.authentication.jwtbearer.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication.microsoftaccount/2.2.0/microsoft.aspnetcore.authentication.microsoftaccount.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication.oauth/2.2.0/microsoft.aspnetcore.authentication.oauth.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication.openidconnect/2.2.0/microsoft.aspnetcore.authentication.openidconnect.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication.twitter/2.2.0/microsoft.aspnetcore.authentication.twitter.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authentication.wsfederation/2.2.0/microsoft.aspnetcore.authentication.wsfederation.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authorization/2.2.0/microsoft.aspnetcore.authorization.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.authorization.policy/2.2.0/microsoft.aspnetcore.authorization.policy.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.azureappservices.hostingstartup/2.2.5/microsoft.aspnetcore.azureappservices.hostingstartup.2.2.5.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.azureappservicesintegration/2.2.5/microsoft.aspnetcore.azureappservicesintegration.2.2.5.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.connections.abstractions/2.2.0/microsoft.aspnetcore.connections.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.cookiepolicy/2.2.8/microsoft.aspnetcore.cookiepolicy.2.2.8.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.cors/2.2.0/microsoft.aspnetcore.cors.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.cryptography.internal/2.2.0/microsoft.aspnetcore.cryptography.internal.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.cryptography.keyderivation/2.2.0/microsoft.aspnetcore.cryptography.keyderivation.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.dataprotection/2.2.0/microsoft.aspnetcore.dataprotection.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.dataprotection.abstractions/2.2.0/microsoft.aspnetcore.dataprotection.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.dataprotection.azurekeyvault/2.2.0/microsoft.aspnetcore.dataprotection.azurekeyvault.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.dataprotection.azurestorage/2.2.7/microsoft.aspnetcore.dataprotection.azurestorage.2.2.7.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.dataprotection.extensions/2.2.0/microsoft.aspnetcore.dataprotection.extensions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.diagnostics/2.2.0/microsoft.aspnetcore.diagnostics.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.diagnostics.abstractions/2.2.0/microsoft.aspnetcore.diagnostics.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.diagnostics.entityframeworkcore/2.2.1/microsoft.aspnetcore.diagnostics.entityframeworkcore.2.2.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.diagnostics.healthchecks/2.2.0/microsoft.aspnetcore.diagnostics.healthchecks.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.hostfiltering/2.2.0/microsoft.aspnetcore.hostfiltering.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.hosting/2.2.7/microsoft.aspnetcore.hosting.2.2.7.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.hosting.abstractions/2.2.0/microsoft.aspnetcore.hosting.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.hosting.server.abstractions/2.2.0/microsoft.aspnetcore.hosting.server.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.html.abstractions/2.2.0/microsoft.aspnetcore.html.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.http/2.2.2/microsoft.aspnetcore.http.2.2.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.http.abstractions/2.2.0/microsoft.aspnetcore.http.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.http.connections/1.1.0/microsoft.aspnetcore.http.connections.1.1.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.http.connections.common/1.1.0/microsoft.aspnetcore.http.connections.common.1.1.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.http.extensions/2.2.0/microsoft.aspnetcore.http.extensions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.http.features/2.2.0/microsoft.aspnetcore.http.features.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.httpoverrides/2.2.0/microsoft.aspnetcore.httpoverrides.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.httpspolicy/2.2.0/microsoft.aspnetcore.httpspolicy.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.identity/2.2.0/microsoft.aspnetcore.identity.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.identity.entityframeworkcore/2.2.0/microsoft.aspnetcore.identity.entityframeworkcore.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.identity.ui/2.2.5/microsoft.aspnetcore.identity.ui.2.2.5.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.jsonpatch/2.2.0/microsoft.aspnetcore.jsonpatch.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.localization/2.2.0/microsoft.aspnetcore.localization.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.localization.routing/2.2.0/microsoft.aspnetcore.localization.routing.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.middlewareanalysis/2.2.0/microsoft.aspnetcore.middlewareanalysis.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc/2.2.0/microsoft.aspnetcore.mvc.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.abstractions/2.2.0/microsoft.aspnetcore.mvc.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.analyzers/2.2.0/microsoft.aspnetcore.mvc.analyzers.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.apiexplorer/2.2.0/microsoft.aspnetcore.mvc.apiexplorer.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.core/2.2.5/microsoft.aspnetcore.mvc.core.2.2.5.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.cors/2.2.0/microsoft.aspnetcore.mvc.cors.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.dataannotations/2.2.0/microsoft.aspnetcore.mvc.dataannotations.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.formatters.json/2.2.0/microsoft.aspnetcore.mvc.formatters.json.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.formatters.xml/2.2.0/microsoft.aspnetcore.mvc.formatters.xml.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.localization/2.2.0/microsoft.aspnetcore.mvc.localization.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.razor/2.2.0/microsoft.aspnetcore.mvc.razor.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.razor.extensions/2.2.0/microsoft.aspnetcore.mvc.razor.extensions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.razor.viewcompilation/2.2.0/microsoft.aspnetcore.mvc.razor.viewcompilation.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.razorpages/2.2.5/microsoft.aspnetcore.mvc.razorpages.2.2.5.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.taghelpers/2.2.0/microsoft.aspnetcore.mvc.taghelpers.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.mvc.viewfeatures/2.2.0/microsoft.aspnetcore.mvc.viewfeatures.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.nodeservices/2.2.0/microsoft.aspnetcore.nodeservices.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.owin/2.2.0/microsoft.aspnetcore.owin.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.razor/2.2.0/microsoft.aspnetcore.razor.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.razor.design/2.2.0/microsoft.aspnetcore.razor.design.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.razor.language/2.2.0/microsoft.aspnetcore.razor.language.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.razor.runtime/2.2.0/microsoft.aspnetcore.razor.runtime.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.responsecaching/2.2.0/microsoft.aspnetcore.responsecaching.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.responsecaching.abstractions/2.2.0/microsoft.aspnetcore.responsecaching.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.responsecompression/2.2.0/microsoft.aspnetcore.responsecompression.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.rewrite/2.2.0/microsoft.aspnetcore.rewrite.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.routing/2.2.2/microsoft.aspnetcore.routing.2.2.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.routing.abstractions/2.2.0/microsoft.aspnetcore.routing.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.server.httpsys/2.2.6/microsoft.aspnetcore.server.httpsys.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.server.iis/2.2.6/microsoft.aspnetcore.server.iis.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.server.iisintegration/2.2.1/microsoft.aspnetcore.server.iisintegration.2.2.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.server.kestrel/2.2.0/microsoft.aspnetcore.server.kestrel.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.server.kestrel.core/2.2.0/microsoft.aspnetcore.server.kestrel.core.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.server.kestrel.https/2.2.0/microsoft.aspnetcore.server.kestrel.https.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.server.kestrel.transport.abstractions/2.2.0/microsoft.aspnetcore.server.kestrel.transport.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.server.kestrel.transport.libuv/2.2.0/microsoft.aspnetcore.server.kestrel.transport.libuv.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.server.kestrel.transport.sockets/2.2.1/microsoft.aspnetcore.server.kestrel.transport.sockets.2.2.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.session/2.2.0/microsoft.aspnetcore.session.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.signalr/1.1.0/microsoft.aspnetcore.signalr.1.1.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.signalr.common/1.1.0/microsoft.aspnetcore.signalr.common.1.1.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.signalr.core/1.1.0/microsoft.aspnetcore.signalr.core.1.1.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.signalr.protocols.json/1.1.0/microsoft.aspnetcore.signalr.protocols.json.1.1.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.signalr.redis/1.1.5/microsoft.aspnetcore.signalr.redis.1.1.5.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.spaservices/2.2.7/microsoft.aspnetcore.spaservices.2.2.7.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.spaservices.extensions/2.2.0/microsoft.aspnetcore.spaservices.extensions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.staticfiles/2.2.0/microsoft.aspnetcore.staticfiles.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.websockets/2.2.1/microsoft.aspnetcore.websockets.2.2.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.aspnetcore.webutilities/2.2.0/microsoft.aspnetcore.webutilities.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.azure.keyvault/2.3.2/microsoft.azure.keyvault.2.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.azure.keyvault.webkey/2.0.7/microsoft.azure.keyvault.webkey.2.0.7.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.azure.services.appauthentication/1.0.1/microsoft.azure.services.appauthentication.1.0.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.codeanalysis.analyzers/1.1.0/microsoft.codeanalysis.analyzers.1.1.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.codeanalysis.common/2.8.0/microsoft.codeanalysis.common.2.8.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.codeanalysis.csharp/2.8.0/microsoft.codeanalysis.csharp.2.8.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.codeanalysis.razor/2.2.0/microsoft.codeanalysis.razor.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.csharp/4.5.0/microsoft.csharp.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.data.edm/5.8.4/microsoft.data.edm.5.8.4.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.data.odata/5.8.4/microsoft.data.odata.5.8.4.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.data.sqlite/2.2.6/microsoft.data.sqlite.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.data.sqlite.core/2.2.6/microsoft.data.sqlite.core.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.dotnet.platformabstractions/2.1.0/microsoft.dotnet.platformabstractions.2.1.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.entityframeworkcore/2.2.6/microsoft.entityframeworkcore.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.entityframeworkcore.abstractions/2.2.6/microsoft.entityframeworkcore.abstractions.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.entityframeworkcore.analyzers/2.2.6/microsoft.entityframeworkcore.analyzers.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.entityframeworkcore.design/2.2.6/microsoft.entityframeworkcore.design.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.entityframeworkcore.inmemory/2.2.6/microsoft.entityframeworkcore.inmemory.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.entityframeworkcore.relational/2.2.6/microsoft.entityframeworkcore.relational.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.entityframeworkcore.sqlite/2.2.6/microsoft.entityframeworkcore.sqlite.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.entityframeworkcore.sqlite.core/2.2.6/microsoft.entityframeworkcore.sqlite.core.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.entityframeworkcore.sqlserver/2.2.6/microsoft.entityframeworkcore.sqlserver.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.entityframeworkcore.tools/2.2.6/microsoft.entityframeworkcore.tools.2.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.caching.abstractions/2.2.0/microsoft.extensions.caching.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.caching.memory/2.2.0/microsoft.extensions.caching.memory.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.caching.redis/2.2.0/microsoft.extensions.caching.redis.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.caching.sqlserver/2.2.0/microsoft.extensions.caching.sqlserver.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration/2.2.0/microsoft.extensions.configuration.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration.abstractions/2.2.0/microsoft.extensions.configuration.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration.azurekeyvault/2.2.0/microsoft.extensions.configuration.azurekeyvault.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration.binder/2.2.4/microsoft.extensions.configuration.binder.2.2.4.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration.commandline/2.2.0/microsoft.extensions.configuration.commandline.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration.environmentvariables/2.2.4/microsoft.extensions.configuration.environmentvariables.2.2.4.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration.fileextensions/2.2.0/microsoft.extensions.configuration.fileextensions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration.ini/2.2.0/microsoft.extensions.configuration.ini.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration.json/2.2.0/microsoft.extensions.configuration.json.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration.keyperfile/2.2.4/microsoft.extensions.configuration.keyperfile.2.2.4.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration.usersecrets/2.2.0/microsoft.extensions.configuration.usersecrets.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.configuration.xml/2.2.0/microsoft.extensions.configuration.xml.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.dependencyinjection/2.2.0/microsoft.extensions.dependencyinjection.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.dependencyinjection.abstractions/2.2.0/microsoft.extensions.dependencyinjection.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.dependencymodel/2.1.0/microsoft.extensions.dependencymodel.2.1.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.diagnosticadapter/2.2.0/microsoft.extensions.diagnosticadapter.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.diagnostics.healthchecks/2.2.5/microsoft.extensions.diagnostics.healthchecks.2.2.5.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.diagnostics.healthchecks.abstractions/2.2.0/microsoft.extensions.diagnostics.healthchecks.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.fileproviders.abstractions/2.2.0/microsoft.extensions.fileproviders.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.fileproviders.composite/2.2.0/microsoft.extensions.fileproviders.composite.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.fileproviders.embedded/2.2.0/microsoft.extensions.fileproviders.embedded.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.fileproviders.physical/2.2.0/microsoft.extensions.fileproviders.physical.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.filesystemglobbing/2.2.0/microsoft.extensions.filesystemglobbing.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.hosting/2.2.0/microsoft.extensions.hosting.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.hosting.abstractions/2.2.0/microsoft.extensions.hosting.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.http/2.2.0/microsoft.extensions.http.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.identity.core/2.2.0/microsoft.extensions.identity.core.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.identity.stores/2.2.0/microsoft.extensions.identity.stores.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.localization/2.2.0/microsoft.extensions.localization.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.localization.abstractions/2.2.0/microsoft.extensions.localization.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.logging/2.2.0/microsoft.extensions.logging.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.logging.abstractions/2.2.0/microsoft.extensions.logging.abstractions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.logging.azureappservices/2.2.5/microsoft.extensions.logging.azureappservices.2.2.5.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.logging.configuration/2.2.0/microsoft.extensions.logging.configuration.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.logging.console/2.2.0/microsoft.extensions.logging.console.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.logging.debug/2.2.0/microsoft.extensions.logging.debug.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.logging.eventsource/2.2.0/microsoft.extensions.logging.eventsource.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.logging.tracesource/2.2.0/microsoft.extensions.logging.tracesource.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.objectpool/2.2.0/microsoft.extensions.objectpool.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.options/2.2.0/microsoft.extensions.options.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.options.configurationextensions/2.2.0/microsoft.extensions.options.configurationextensions.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.options.dataannotations/2.2.0/microsoft.extensions.options.dataannotations.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.platformabstractions/1.1.0/microsoft.extensions.platformabstractions.1.1.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.primitives/2.2.0/microsoft.extensions.primitives.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.extensions.webencoders/2.2.0/microsoft.extensions.webencoders.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.identitymodel.clients.activedirectory/3.19.8/microsoft.identitymodel.clients.activedirectory.3.19.8.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.identitymodel.jsonwebtokens/5.3.0/microsoft.identitymodel.jsonwebtokens.5.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.identitymodel.logging/5.3.0/microsoft.identitymodel.logging.5.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.identitymodel.protocols/5.3.0/microsoft.identitymodel.protocols.5.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.identitymodel.protocols.openidconnect/5.3.0/microsoft.identitymodel.protocols.openidconnect.5.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.identitymodel.protocols.wsfederation/5.3.0/microsoft.identitymodel.protocols.wsfederation.5.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.identitymodel.tokens/5.3.0/microsoft.identitymodel.tokens.5.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.identitymodel.tokens.saml/5.3.0/microsoft.identitymodel.tokens.saml.5.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.identitymodel.xml/5.3.0/microsoft.identitymodel.xml.5.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.net.http.headers/2.2.8/microsoft.net.http.headers.2.2.8.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.netcore.app/2.2.8/microsoft.netcore.app.2.2.8.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.netcore.dotnetapphost/2.2.8/microsoft.netcore.dotnetapphost.2.2.8.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.netcore.dotnethostpolicy/2.2.8/microsoft.netcore.dotnethostpolicy.2.2.8.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.netcore.dotnethostresolver/2.2.8/microsoft.netcore.dotnethostresolver.2.2.8.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.netcore.platforms/2.2.4/microsoft.netcore.platforms.2.2.4.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.netcore.targets/2.0.0/microsoft.netcore.targets.2.0.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.rest.clientruntime/2.3.8/microsoft.rest.clientruntime.2.3.8.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.rest.clientruntime.azure/3.3.7/microsoft.rest.clientruntime.azure.3.3.7.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.visualstudio.web.browserlink/2.2.0/microsoft.visualstudio.web.browserlink.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.win32.primitives/4.3.0/microsoft.win32.primitives.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/microsoft.win32.registry/4.5.0/microsoft.win32.registry.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/netstandard.library/2.0.3/netstandard.library.2.0.3.nupkg.sha512",
+    "/Volumes/TheD/.nuget/newtonsoft.json/11.0.2/newtonsoft.json.11.0.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/newtonsoft.json.bson/1.0.1/newtonsoft.json.bson.1.0.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/octokit/0.36.0/octokit.0.36.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/remotion.linq/2.2.0/remotion.linq.2.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.debian.8-x64.runtime.native.system.security.cryptography.openssl/4.3.2/runtime.debian.8-x64.runtime.native.system.security.cryptography.openssl.4.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.fedora.23-x64.runtime.native.system.security.cryptography.openssl/4.3.2/runtime.fedora.23-x64.runtime.native.system.security.cryptography.openssl.4.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.fedora.24-x64.runtime.native.system.security.cryptography.openssl/4.3.2/runtime.fedora.24-x64.runtime.native.system.security.cryptography.openssl.4.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.native.system/4.3.0/runtime.native.system.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.native.system.data.sqlclient.sni/4.5.0/runtime.native.system.data.sqlclient.sni.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.native.system.io.compression/4.3.0/runtime.native.system.io.compression.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.native.system.net.http/4.3.0/runtime.native.system.net.http.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.native.system.net.security/4.3.0/runtime.native.system.net.security.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.native.system.security.cryptography.apple/4.3.1/runtime.native.system.security.cryptography.apple.4.3.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.native.system.security.cryptography.openssl/4.3.2/runtime.native.system.security.cryptography.openssl.4.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.opensuse.13.2-x64.runtime.native.system.security.cryptography.openssl/4.3.2/runtime.opensuse.13.2-x64.runtime.native.system.security.cryptography.openssl.4.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.opensuse.42.1-x64.runtime.native.system.security.cryptography.openssl/4.3.2/runtime.opensuse.42.1-x64.runtime.native.system.security.cryptography.openssl.4.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.osx.10.10-x64.runtime.native.system.security.cryptography.apple/4.3.1/runtime.osx.10.10-x64.runtime.native.system.security.cryptography.apple.4.3.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.osx.10.10-x64.runtime.native.system.security.cryptography.openssl/4.3.2/runtime.osx.10.10-x64.runtime.native.system.security.cryptography.openssl.4.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.rhel.7-x64.runtime.native.system.security.cryptography.openssl/4.3.2/runtime.rhel.7-x64.runtime.native.system.security.cryptography.openssl.4.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.ubuntu.14.04-x64.runtime.native.system.security.cryptography.openssl/4.3.2/runtime.ubuntu.14.04-x64.runtime.native.system.security.cryptography.openssl.4.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.ubuntu.16.04-x64.runtime.native.system.security.cryptography.openssl/4.3.2/runtime.ubuntu.16.04-x64.runtime.native.system.security.cryptography.openssl.4.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.ubuntu.16.10-x64.runtime.native.system.security.cryptography.openssl/4.3.2/runtime.ubuntu.16.10-x64.runtime.native.system.security.cryptography.openssl.4.3.2.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.win-arm64.runtime.native.system.data.sqlclient.sni/4.4.0/runtime.win-arm64.runtime.native.system.data.sqlclient.sni.4.4.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.win-x64.runtime.native.system.data.sqlclient.sni/4.4.0/runtime.win-x64.runtime.native.system.data.sqlclient.sni.4.4.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/runtime.win-x86.runtime.native.system.data.sqlclient.sni/4.4.0/runtime.win-x86.runtime.native.system.data.sqlclient.sni.4.4.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/sqlitepclraw.bundle_green/1.1.12/sqlitepclraw.bundle_green.1.1.12.nupkg.sha512",
+    "/Volumes/TheD/.nuget/sqlitepclraw.core/1.1.12/sqlitepclraw.core.1.1.12.nupkg.sha512",
+    "/Volumes/TheD/.nuget/sqlitepclraw.lib.e_sqlite3.linux/1.1.12/sqlitepclraw.lib.e_sqlite3.linux.1.1.12.nupkg.sha512",
+    "/Volumes/TheD/.nuget/sqlitepclraw.lib.e_sqlite3.osx/1.1.12/sqlitepclraw.lib.e_sqlite3.osx.1.1.12.nupkg.sha512",
+    "/Volumes/TheD/.nuget/sqlitepclraw.lib.e_sqlite3.v110_xp/1.1.12/sqlitepclraw.lib.e_sqlite3.v110_xp.1.1.12.nupkg.sha512",
+    "/Volumes/TheD/.nuget/sqlitepclraw.provider.e_sqlite3.netstandard11/1.1.12/sqlitepclraw.provider.e_sqlite3.netstandard11.1.1.12.nupkg.sha512",
+    "/Volumes/TheD/.nuget/stackexchange.redis.strongname/1.2.6/stackexchange.redis.strongname.1.2.6.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.appcontext/4.3.0/system.appcontext.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.buffers/4.5.0/system.buffers.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.collections/4.3.0/system.collections.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.collections.concurrent/4.3.0/system.collections.concurrent.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.collections.immutable/1.5.0/system.collections.immutable.1.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.collections.nongeneric/4.3.0/system.collections.nongeneric.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.collections.specialized/4.3.0/system.collections.specialized.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.componentmodel.annotations/4.5.0/system.componentmodel.annotations.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.console/4.3.0/system.console.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.data.sqlclient/4.6.1/system.data.sqlclient.4.6.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.diagnostics.contracts/4.3.0/system.diagnostics.contracts.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.diagnostics.debug/4.3.0/system.diagnostics.debug.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.diagnostics.diagnosticsource/4.5.1/system.diagnostics.diagnosticsource.4.5.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.diagnostics.fileversioninfo/4.3.0/system.diagnostics.fileversioninfo.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.diagnostics.process/4.3.0/system.diagnostics.process.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.diagnostics.stacktrace/4.3.0/system.diagnostics.stacktrace.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.diagnostics.tools/4.3.0/system.diagnostics.tools.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.diagnostics.tracing/4.3.0/system.diagnostics.tracing.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.dynamic.runtime/4.3.0/system.dynamic.runtime.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.globalization/4.3.0/system.globalization.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.globalization.calendars/4.3.0/system.globalization.calendars.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.globalization.extensions/4.3.0/system.globalization.extensions.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.identitymodel.tokens.jwt/5.3.0/system.identitymodel.tokens.jwt.5.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.interactive.async/3.2.0/system.interactive.async.3.2.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.io/4.3.0/system.io.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.io.compression/4.3.0/system.io.compression.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.io.filesystem/4.3.0/system.io.filesystem.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.io.filesystem.primitives/4.3.0/system.io.filesystem.primitives.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.io.pipelines/4.5.3/system.io.pipelines.4.5.3.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.linq/4.3.0/system.linq.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.linq.expressions/4.3.0/system.linq.expressions.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.linq.queryable/4.0.1/system.linq.queryable.4.0.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.memory/4.5.1/system.memory.4.5.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.net.http/4.3.0/system.net.http.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.net.nameresolution/4.3.0/system.net.nameresolution.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.net.primitives/4.3.0/system.net.primitives.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.net.security/4.3.0/system.net.security.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.net.sockets/4.3.0/system.net.sockets.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.net.websockets.websocketprotocol/4.5.3/system.net.websockets.websocketprotocol.4.5.3.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.numerics.vectors/4.5.0/system.numerics.vectors.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.objectmodel/4.3.0/system.objectmodel.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.private.datacontractserialization/4.3.0/system.private.datacontractserialization.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.reflection/4.3.0/system.reflection.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.reflection.emit/4.3.0/system.reflection.emit.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.reflection.emit.ilgeneration/4.3.0/system.reflection.emit.ilgeneration.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.reflection.emit.lightweight/4.3.0/system.reflection.emit.lightweight.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.reflection.extensions/4.3.0/system.reflection.extensions.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.reflection.metadata/1.6.0/system.reflection.metadata.1.6.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.reflection.primitives/4.3.0/system.reflection.primitives.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.reflection.typeextensions/4.3.0/system.reflection.typeextensions.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.resources.resourcemanager/4.3.0/system.resources.resourcemanager.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.runtime/4.3.0/system.runtime.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.runtime.compilerservices.unsafe/4.5.1/system.runtime.compilerservices.unsafe.4.5.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.runtime.extensions/4.3.0/system.runtime.extensions.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.runtime.handles/4.3.0/system.runtime.handles.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.runtime.interopservices/4.3.0/system.runtime.interopservices.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.runtime.interopservices.runtimeinformation/4.3.0/system.runtime.interopservices.runtimeinformation.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.runtime.numerics/4.3.0/system.runtime.numerics.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.runtime.serialization.json/4.3.0/system.runtime.serialization.json.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.runtime.serialization.primitives/4.3.0/system.runtime.serialization.primitives.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.runtime.serialization.xml/4.3.0/system.runtime.serialization.xml.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.accesscontrol/4.5.0/system.security.accesscontrol.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.claims/4.3.0/system.security.claims.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.cryptography.algorithms/4.3.1/system.security.cryptography.algorithms.4.3.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.cryptography.cng/4.5.0/system.security.cryptography.cng.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.cryptography.csp/4.3.0/system.security.cryptography.csp.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.cryptography.encoding/4.3.0/system.security.cryptography.encoding.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.cryptography.openssl/4.3.0/system.security.cryptography.openssl.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.cryptography.pkcs/4.5.0/system.security.cryptography.pkcs.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.cryptography.primitives/4.3.0/system.security.cryptography.primitives.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.cryptography.x509certificates/4.3.0/system.security.cryptography.x509certificates.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.cryptography.xml/4.5.0/system.security.cryptography.xml.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.permissions/4.5.0/system.security.permissions.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.principal/4.3.0/system.security.principal.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.security.principal.windows/4.5.0/system.security.principal.windows.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.spatial/5.8.4/system.spatial.5.8.4.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.text.encoding/4.3.0/system.text.encoding.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.text.encoding.codepages/4.5.0/system.text.encoding.codepages.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.text.encoding.extensions/4.3.0/system.text.encoding.extensions.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.text.encodings.web/4.5.0/system.text.encodings.web.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.text.regularexpressions/4.3.0/system.text.regularexpressions.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.threading/4.3.0/system.threading.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.threading.channels/4.5.0/system.threading.channels.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.threading.tasks/4.3.0/system.threading.tasks.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.threading.tasks.extensions/4.5.1/system.threading.tasks.extensions.4.5.1.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.threading.tasks.parallel/4.3.0/system.threading.tasks.parallel.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.threading.thread/4.3.0/system.threading.thread.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.threading.threadpool/4.3.0/system.threading.threadpool.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.threading.timer/4.3.0/system.threading.timer.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.valuetuple/4.5.0/system.valuetuple.4.5.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.xml.readerwriter/4.3.0/system.xml.readerwriter.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.xml.xdocument/4.3.0/system.xml.xdocument.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.xml.xmldocument/4.3.0/system.xml.xmldocument.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.xml.xmlserializer/4.3.0/system.xml.xmlserializer.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.xml.xpath/4.3.0/system.xml.xpath.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/system.xml.xpath.xdocument/4.3.0/system.xml.xpath.xdocument.4.3.0.nupkg.sha512",
+    "/Volumes/TheD/.nuget/windowsazure.storage/8.1.4/windowsazure.storage.8.1.4.nupkg.sha512"
+  ],
+  "logs": []
+}