Ignore:
Timestamp:
Aug 6, 2022, 11:32:32 PM (2 years ago)
Author:
alloc
Message:

Big refactoring in Web to pass around a Context instead of a bunch of individual arguments all the time

Location:
binary-improvements2/MapRendering/Web/API
Files:
16 edited
1 moved

Legend:

Unmodified
Added
Removed

  • binary-improvements2/MapRendering/Web/API/AbsWebAPI.cs

    r386 r387  
    1 using System.Text;
    2 using AllocsFixes.JSON;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    5 
    61namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public abstract class WebAPI {
     2        public abstract class AbsWebAPI {
    83                public readonly string Name;
    94
    10                 protected WebAPI (string _name = null) {
     5                protected AbsWebAPI (string _name = null) {
    116                        Name = _name ?? GetType ().Name;
    127                }
    138
    14 #if ENABLE_PROFILER
    15                 private static readonly UnityEngine.Profiling.CustomSampler jsonSerializeSampler = UnityEngine.Profiling.CustomSampler.Create ("JSON_Serialize");
    16                 private static readonly UnityEngine.Profiling.CustomSampler netWriteSampler = UnityEngine.Profiling.CustomSampler.Create ("JSON_Write");
    17 #endif
    18 
    19                 public static void WriteJSON (HttpListenerResponse _resp, JSONNode _root) {
    20 #if ENABLE_PROFILER
    21                         jsonSerializeSampler.Begin ();
    22 #endif
    23                         StringBuilder sb = new StringBuilder ();
    24                         _root.ToString (sb);
    25 #if ENABLE_PROFILER
    26                         jsonSerializeSampler.End ();
    27                         netWriteSampler.Begin ();
    28 #endif
    29                         byte[] buf = Encoding.UTF8.GetBytes (sb.ToString ());
    30                         _resp.ContentLength64 = buf.Length;
    31                         _resp.ContentType = "application/json";
    32                         _resp.ContentEncoding = Encoding.UTF8;
    33                         _resp.OutputStream.Write (buf, 0, buf.Length);
    34 #if ENABLE_PROFILER
    35                         netWriteSampler.End ();
    36 #endif
    37                 }
    38 
    39                 public static void WriteText (HttpListenerResponse _resp, string _text) {
    40                         byte[] buf = Encoding.UTF8.GetBytes (_text);
    41                         _resp.ContentLength64 = buf.Length;
    42                         _resp.ContentType = "text/plain";
    43                         _resp.ContentEncoding = Encoding.UTF8;
    44                         _resp.OutputStream.Write (buf, 0, buf.Length);
    45                 }
    46 
    47                 public abstract void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp,
    48                         WebConnection _user, int _permissionLevel);
     9                public abstract void HandleRequest (RequestContext _context);
    4910
    5011                public virtual int DefaultPermissionLevel () {

  • binary-improvements2/MapRendering/Web/API/ExecuteConsoleCommand.cs

    r382 r387  
    11using System;
    22using System.Net;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    53
    64namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class ExecuteConsoleCommand : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
    10                         if (string.IsNullOrEmpty (_req.QueryString ["command"])) {
    11                                 _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    12                                 Web.SetResponseTextContent (_resp, "No command given");
     5        public class ExecuteConsoleCommand : AbsWebAPI {
     6                public override void HandleRequest (RequestContext _context) {
     7                        if (string.IsNullOrEmpty (_context.Request.QueryString ["command"])) {
     8                                WebUtils.WriteText (_context.Response, "No command given", HttpStatusCode.BadRequest);
    139                                return;
    1410                        }
    1511
    1612                        WebCommandResult.ResultType responseType =
    17                                 _req.QueryString ["raw"] != null
     13                                _context.Request.QueryString ["raw"] != null
    1814                                        ? WebCommandResult.ResultType.Raw
    19                                         : (_req.QueryString ["simple"] != null
     15                                        : (_context.Request.QueryString ["simple"] != null
    2016                                                ? WebCommandResult.ResultType.ResultOnly
    2117                                                : WebCommandResult.ResultType.Full);
    2218
    23                         string commandline = _req.QueryString ["command"];
     19                        string commandline = _context.Request.QueryString ["command"];
    2420                        string commandPart = commandline.Split (' ') [0];
    2521                        string argumentsPart = commandline.Substring (Math.Min (commandline.Length, commandPart.Length + 1));
    … …  
    2824
    2925                        if (command == null) {
    30                                 _resp.StatusCode = (int) HttpStatusCode.NotFound;
    31                                 Web.SetResponseTextContent (_resp, "Unknown command");
     26                                WebUtils.WriteText (_context.Response, "Unknown command", HttpStatusCode.NotFound);
    3227                                return;
    3328                        }
    … …  
    3530                        int commandPermissionLevel = GameManager.Instance.adminTools.GetCommandPermissionLevel (command.GetCommands ());
    3631
    37                         if (_permissionLevel > commandPermissionLevel) {
    38                                 _resp.StatusCode = (int) HttpStatusCode.Forbidden;
    39                                 Web.SetResponseTextContent (_resp, "You are not allowed to execute this command");
     32                        if (_context.PermissionLevel > commandPermissionLevel) {
     33                                WebUtils.WriteText (_context.Response, "You are not allowed to execute this command", HttpStatusCode.Forbidden);
    4034                                return;
    4135                        }
    4236
    43                         _resp.SendChunked = true;
    44                         WebCommandResult wcr = new WebCommandResult (commandPart, argumentsPart, responseType, _resp);
     37                        _context.Response.SendChunked = true;
     38                        WebCommandResult wcr = new WebCommandResult (commandPart, argumentsPart, responseType, _context.Response);
    4539                        SdtdConsole.Instance.ExecuteAsync (commandline, wcr);
    4640                }

  • binary-improvements2/MapRendering/Web/API/GetAllowedCommands.cs

    r383 r387  
    11using AllocsFixes.JSON;
    2 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    3 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    42
    53namespace AllocsFixes.NetConnections.Servers.Web.API {
    6         public class GetAllowedCommands : WebAPI {
    7                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    8                         int _permissionLevel) {
     4        public class GetAllowedCommands : AbsWebAPI {
     5                public override void HandleRequest (RequestContext _context) {
    96                        JSONObject result = new JSONObject ();
    107                        JSONArray entries = new JSONArray ();
    118                        foreach (IConsoleCommand cc in SdtdConsole.Instance.GetCommands ()) {
    129                                int commandPermissionLevel = GameManager.Instance.adminTools.GetCommandPermissionLevel (cc.GetCommands ());
    13                                 if (_permissionLevel <= commandPermissionLevel) {
     10                                if (_context.PermissionLevel <= commandPermissionLevel) {
    1411                                        string cmd = string.Empty;
    1512                                        foreach (string s in cc.GetCommands ()) {
    … …  
    2926                        result.Add ("commands", entries);
    3027
    31                         WriteJSON (_resp, result);
     28                        WebUtils.WriteJson (_context.Response, result);
    3229                }
    3330

  • binary-improvements2/MapRendering/Web/API/GetAnimalsLocation.cs

    r383 r387  
    22using AllocsFixes.JSON;
    33using AllocsFixes.LiveData;
    4 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    5 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    64
    75namespace AllocsFixes.NetConnections.Servers.Web.API {
    8         internal class GetAnimalsLocation : WebAPI {
     6        internal class GetAnimalsLocation : AbsWebAPI {
    97                private readonly List<EntityAnimal> animals = new List<EntityAnimal> ();
    108
    11                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    12                         int _permissionLevel) {
     9                public override void HandleRequest (RequestContext _context) {
    1310                        JSONArray animalsJsResult = new JSONArray ();
    1411
    … …  
    3734                        }
    3835
    39                         WriteJSON (_resp, animalsJsResult);
     36                        WebUtils.WriteJson (_context.Response, animalsJsResult);
    4037                }
    4138        }

  • binary-improvements2/MapRendering/Web/API/GetHostileLocation.cs

    r383 r387  
    22using AllocsFixes.JSON;
    33using AllocsFixes.LiveData;
    4 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    5 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    64
    75namespace AllocsFixes.NetConnections.Servers.Web.API {
    8         internal class GetHostileLocation : WebAPI {
     6        internal class GetHostileLocation : AbsWebAPI {
    97                private readonly List<EntityEnemy> enemies = new List<EntityEnemy> ();
    108
    11                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    12                         int _permissionLevel) {
     9                public override void HandleRequest (RequestContext _context) {
    1310                        JSONArray hostilesJsResult = new JSONArray ();
    1411
    … …  
    3734                        }
    3835
    39                         WriteJSON (_resp, hostilesJsResult);
     36                        WebUtils.WriteJson (_context.Response, hostilesJsResult);
    4037                }
    4138        }

  • binary-improvements2/MapRendering/Web/API/GetLandClaims.cs

    r382 r387  
    33using AllocsFixes.JSON;
    44using AllocsFixes.PersistentData;
    5 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    6 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    75
    86namespace AllocsFixes.NetConnections.Servers.Web.API {
    9         public class GetLandClaims : WebAPI {
    10                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    11                         int _permissionLevel) {
     7        public class GetLandClaims : AbsWebAPI {
     8                public override void HandleRequest (RequestContext _context) {
    129                        PlatformUserIdentifierAbs requestedUserId = null;
    13                         if (_req.QueryString ["userid"] != null) {
    14                                 if (!PlatformUserIdentifierAbs.TryFromCombinedString (_req.QueryString ["userid"], out requestedUserId)) {
    15                                         _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    16                                         Web.SetResponseTextContent (_resp, "Invalid user id given");
     10                        if (_context.Request.QueryString ["userid"] != null) {
     11                                if (!PlatformUserIdentifierAbs.TryFromCombinedString (_context.Request.QueryString ["userid"], out requestedUserId)) {
     12                                        WebUtils.WriteText (_context.Response, "Invalid user id given", HttpStatusCode.BadRequest);
    1713                                        return;
    1814                                }
    … …  
    2016
    2117                        // default user, cheap way to avoid 'null reference exception'
    22                         PlatformUserIdentifierAbs userId = _user?.UserId;
     18                        PlatformUserIdentifierAbs userId = _context.Connection?.UserId;
    2319
    24                         bool bViewAll = WebConnection.CanViewAllClaims (_permissionLevel);
     20                        bool bViewAll = WebConnection.CanViewAllClaims (_context.PermissionLevel);
    2521
    2622                        JSONObject result = new JSONObject ();
    … …  
    7470                        }
    7571
    76                         WriteJSON (_resp, result);
     72                        WebUtils.WriteJson (_context.Response, result);
    7773                }
    7874        }

  • binary-improvements2/MapRendering/Web/API/GetLog.cs

    r383 r387  
    11using System.Collections.Generic;
    22using AllocsFixes.JSON;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    53
    64namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetLog : WebAPI {
     5        public class GetLog : AbsWebAPI {
    86                private const int MAX_COUNT = 1000;
    97               
    10                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    11                         int _permissionLevel) {
    12                         if (_req.QueryString ["count"] == null || !int.TryParse (_req.QueryString ["count"], out int count)) {
     8                public override void HandleRequest (RequestContext _context) {
     9                        if (_context.Request.QueryString ["count"] == null || !int.TryParse (_context.Request.QueryString ["count"], out int count)) {
    1310                                count = 50;
    1411                        }
    … …  
    2623                        }
    2724
    28                         if (_req.QueryString ["firstLine"] == null || !int.TryParse (_req.QueryString ["firstLine"], out int firstLine)) {
     25                        if (_context.Request.QueryString ["firstLine"] == null || !int.TryParse (_context.Request.QueryString ["firstLine"], out int firstLine)) {
    2926                                firstLine = count > 0 ? LogBuffer.Instance.OldestLine : LogBuffer.Instance.LatestLine;
    3027                        }
    … …  
    3734                        foreach (LogBuffer.LogEntry logEntry in logEntries) {
    3835                                JSONObject entry = new JSONObject ();
    39                                 entry.Add ("date", new JSONString (logEntry.date));
    40                                 entry.Add ("time", new JSONString (logEntry.time));
    4136                                entry.Add ("isotime", new JSONString (logEntry.isoTime));
    4237                                entry.Add ("uptime", new JSONString (logEntry.uptime.ToString ()));
    … …  
    5146                        result.Add ("entries", entries);
    5247
    53                         WriteJSON (_resp, result);
     48                        WebUtils.WriteJson (_context.Response, result);
    5449                }
    5550        }

  • binary-improvements2/MapRendering/Web/API/GetPlayerInventories.cs

    r383 r387  
    22using AllocsFixes.JSON;
    33using AllocsFixes.PersistentData;
    4 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    5 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    64
    75namespace AllocsFixes.NetConnections.Servers.Web.API {
    8         public class GetPlayerInventories : WebAPI {
    9                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    10                         int _permissionLevel) {
    11                         GetPlayerInventory.GetInventoryArguments (_req, out bool showIconColor, out bool showIconName);
     6        public class GetPlayerInventories : AbsWebAPI {
     7                public override void HandleRequest (RequestContext _context) {
     8                        GetPlayerInventory.GetInventoryArguments (_context.Request, out bool showIconColor, out bool showIconName);
    129
    1310                        JSONArray AllInventoriesResult = new JSONArray ();
    … …  
    2522                        }
    2623
    27                         WriteJSON (_resp, AllInventoriesResult);
     24                        WebUtils.WriteJson (_context.Response, AllInventoriesResult);
    2825                }
    2926        }

  • binary-improvements2/MapRendering/Web/API/GetPlayerInventory.cs

    r382 r387  
    44using AllocsFixes.PersistentData;
    55using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    6 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    76
    87namespace AllocsFixes.NetConnections.Servers.Web.API {
    9         public class GetPlayerInventory : WebAPI {
    10                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp,
    11                         WebConnection _user, int _permissionLevel) {
    12                         if (_req.QueryString ["userid"] == null) {
    13                                 _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    14                                 Web.SetResponseTextContent (_resp, "No user id given");
     8        public class GetPlayerInventory : AbsWebAPI {
     9                public override void HandleRequest (RequestContext _context) {
     10                        if (_context.Request.QueryString ["userid"] == null) {
     11                                WebUtils.WriteText (_context.Response, "No user id given", HttpStatusCode.BadRequest);
    1512                                return;
    1613                        }
    1714
    18                         string userIdString = _req.QueryString ["userid"];
     15                        string userIdString = _context.Request.QueryString ["userid"];
    1916                        if (!PlatformUserIdentifierAbs.TryFromCombinedString (userIdString, out PlatformUserIdentifierAbs userId)) {
    20                                 _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    21                                 Web.SetResponseTextContent (_resp, "Invalid user id given");
     17                                WebUtils.WriteText (_context.Response, "Invalid user id given", HttpStatusCode.BadRequest);
    2218                                return;
    2319                        }
    … …  
    2521                        Player p = PersistentContainer.Instance.Players [userId, false];
    2622                        if (p == null) {
    27                                 _resp.StatusCode = (int) HttpStatusCode.NotFound;
    28                                 Web.SetResponseTextContent (_resp, "Unknown user id given");
     23                                WebUtils.WriteText (_context.Response, "Unknown user id given", HttpStatusCode.NotFound);
    2924                                return;
    3025                        }
    3126
    32                         GetInventoryArguments (_req, out bool showIconColor, out bool showIconName);
     27                        GetInventoryArguments (_context.Request, out bool showIconColor, out bool showIconName);
    3328
    3429                        JSONObject result = DoPlayer (userIdString, p, showIconColor, showIconName);
    3530
    36                         WriteJSON (_resp, result);
     31                        WebUtils.WriteJson (_context.Response, result);
    3732                }
    3833

  • binary-improvements2/MapRendering/Web/API/GetPlayerList.cs

    r383 r387  
    55using AllocsFixes.JSON;
    66using AllocsFixes.PersistentData;
    7 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    8 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    97
    108namespace AllocsFixes.NetConnections.Servers.Web.API {
    11         public class GetPlayerList : WebAPI {
     9        public class GetPlayerList : AbsWebAPI {
    1210                private static readonly Regex numberFilterMatcher =
    1311                        new Regex (@"^(>=|=>|>|<=|=<|<|==|=)?\s*([0-9]+(\.[0-9]*)?)$");
    … …  
    1715#endif
    1816
    19                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    20                         int _permissionLevel) {
     17                public override void HandleRequest (RequestContext _context) {
    2118                        AdminTools admTools = GameManager.Instance.adminTools;
    22                         PlatformUserIdentifierAbs userId = _user?.UserId;
    23 
    24                         bool bViewAll = WebConnection.CanViewAllPlayers (_permissionLevel);
     19                        PlatformUserIdentifierAbs userId = _context.Connection?.UserId;
     20
     21                        bool bViewAll = WebConnection.CanViewAllPlayers (_context.PermissionLevel);
    2522
    2623                        // TODO: Sort (and filter?) prior to converting to JSON ... hard as how to get the correct column's data? (i.e. column name matches JSON object field names, not source data)
    2724
    2825                        int rowsPerPage = 25;
    29                         if (_req.QueryString ["rowsperpage"] != null) {
    30                                 int.TryParse (_req.QueryString ["rowsperpage"], out rowsPerPage);
     26                        if (_context.Request.QueryString ["rowsperpage"] != null) {
     27                                int.TryParse (_context.Request.QueryString ["rowsperpage"], out rowsPerPage);
    3128                        }
    3229
    3330                        int page = 0;
    34                         if (_req.QueryString ["page"] != null) {
    35                                 int.TryParse (_req.QueryString ["page"], out page);
     31                        if (_context.Request.QueryString ["page"] != null) {
     32                                int.TryParse (_context.Request.QueryString ["page"], out page);
    3633                        }
    3734
    … …  
    8380                        IEnumerable<JSONObject> list = playerList;
    8481
    85                         foreach (string key in _req.QueryString.AllKeys) {
     82                        foreach (string key in _context.Request.QueryString.AllKeys) {
    8683                                if (!string.IsNullOrEmpty (key) && key.StartsWith ("filter[")) {
    8784                                        string filterCol = key.Substring (key.IndexOf ('[') + 1);
    8885                                        filterCol = filterCol.Substring (0, filterCol.Length - 1);
    89                                         string filterVal = _req.QueryString.Get (key).Trim ();
     86                                        string filterVal = _context.Request.QueryString.Get (key).Trim ();
    9087
    9188                                        list = ExecuteFilter (list, filterCol, filterVal);
    … …  
    9592                        int totalAfterFilter = list.Count ();
    9693
    97                         foreach (string key in _req.QueryString.AllKeys) {
     94                        foreach (string key in _context.Request.QueryString.AllKeys) {
    9895                                if (!string.IsNullOrEmpty (key) && key.StartsWith ("sort[")) {
    9996                                        string sortCol = key.Substring (key.IndexOf ('[') + 1);
    10097                                        sortCol = sortCol.Substring (0, sortCol.Length - 1);
    101                                         string sortVal = _req.QueryString.Get (key);
     98                                        string sortVal = _context.Request.QueryString.Get (key);
    10299
    103100                                        list = ExecuteSort (list, sortCol, sortVal == "0");
    … …  
    120117                        result.Add ("players", playersJsResult);
    121118
    122                         WriteJSON (_resp, result);
     119                        WebUtils.WriteJson (_context.Response, result);
    123120                }
    124121

  • binary-improvements2/MapRendering/Web/API/GetPlayersLocation.cs

    r383 r387  
    22using AllocsFixes.JSON;
    33using AllocsFixes.PersistentData;
    4 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    5 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    64
    75namespace AllocsFixes.NetConnections.Servers.Web.API {
    8         public class GetPlayersLocation : WebAPI {
    9                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    10                         int _permissionLevel) {
     6        public class GetPlayersLocation : AbsWebAPI {
     7                public override void HandleRequest (RequestContext _context) {
    118                        AdminTools admTools = GameManager.Instance.adminTools;
    12                         PlatformUserIdentifierAbs userId = _user?.UserId;
     9                        PlatformUserIdentifierAbs userId = _context.Connection?.UserId;
    1310
    1411                        bool listOffline = false;
    15                         if (_req.QueryString ["offline"] != null) {
    16                                 bool.TryParse (_req.QueryString ["offline"], out listOffline);
     12                        if (_context.Request.QueryString ["offline"] != null) {
     13                                bool.TryParse (_context.Request.QueryString ["offline"], out listOffline);
    1714                        }
    1815
    19                         bool bViewAll = WebConnection.CanViewAllPlayers (_permissionLevel);
     16                        bool bViewAll = WebConnection.CanViewAllPlayers (_context.PermissionLevel);
    2017
    2118                        JSONArray playersJsResult = new JSONArray ();
    … …  
    5754                        }
    5855
    59                         WriteJSON (_resp, playersJsResult);
     56                        WebUtils.WriteJson (_context.Response, playersJsResult);
    6057                }
    6158        }

  • binary-improvements2/MapRendering/Web/API/GetPlayersOnline.cs

    r383 r387  
    22using AllocsFixes.JSON;
    33using AllocsFixes.PersistentData;
    4 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    5 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    64
    75namespace AllocsFixes.NetConnections.Servers.Web.API {
    8         public class GetPlayersOnline : WebAPI {
    9                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    10                         int _permissionLevel) {
     6        public class GetPlayersOnline : AbsWebAPI {
     7                public override void HandleRequest (RequestContext _context) {
    118                        JSONArray players = new JSONArray ();
    129
    … …  
    4441                        }
    4542
    46                         WriteJSON (_resp, players);
     43                        WebUtils.WriteJson (_context.Response, players);
    4744                }
    4845        }

  • binary-improvements2/MapRendering/Web/API/GetServerInfo.cs

    r383 r387  
    11using System;
    22using AllocsFixes.JSON;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    53
    64namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetServerInfo : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
     5        public class GetServerInfo : AbsWebAPI {
     6                public override void HandleRequest (RequestContext _context) {
    107                        JSONObject serverInfo = new JSONObject ();
    118
    … …  
    4340
    4441
    45                         WriteJSON (_resp, serverInfo);
     42                        WebUtils.WriteJson (_context.Response, serverInfo);
    4643                }
    4744        }

  • binary-improvements2/MapRendering/Web/API/GetStats.cs

    r383 r387  
    11using AllocsFixes.JSON;
    22using AllocsFixes.LiveData;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    53
    64namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetStats : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
     5        public class GetStats : AbsWebAPI {
     6                public override void HandleRequest (RequestContext _context) {
    107                        JSONObject result = new JSONObject ();
    118
    … …  
    2017                        result.Add ("animals", new JSONNumber (Animals.Instance.GetCount ()));
    2118
    22                         WriteJSON (_resp, result);
     19                        WebUtils.WriteJson (_context.Response, result);
    2320                }
    2421

  • binary-improvements2/MapRendering/Web/API/GetWebMods.cs

    r384 r387  
    11using AllocsFixes.JSON;
    2 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    3 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    42
    53namespace AllocsFixes.NetConnections.Servers.Web.API {
    6         public class GetWebMods : WebAPI {
     4        public class GetWebMods : AbsWebAPI {
    75                private readonly JSONArray loadedWebMods = new JSONArray ();
    86
    … …  
    2725                }
    2826
    29                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    30                         int _permissionLevel) {
    31 
    32                         WriteJSON (_resp, loadedWebMods);
     27                public override void HandleRequest (RequestContext _context) {
     28                        WebUtils.WriteJson (_context.Response, loadedWebMods);
    3329                }
    3430

  • binary-improvements2/MapRendering/Web/API/GetWebUIUpdates.cs

    r383 r387  
    11using AllocsFixes.JSON;
    22using AllocsFixes.LiveData;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    53
    64namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetWebUIUpdates : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
     5        public class GetWebUIUpdates : AbsWebAPI {
     6                public override void HandleRequest (RequestContext _context) {
    107                        int latestLine;
    11                         if (_req.QueryString ["latestLine"] == null ||
    12                             !int.TryParse (_req.QueryString ["latestLine"], out latestLine)) {
     8                        if (_context.Request.QueryString ["latestLine"] == null ||
     9                            !int.TryParse (_context.Request.QueryString ["latestLine"], out latestLine)) {
    1310                                latestLine = 0;
    1411                        }
    … …  
    2825                        result.Add ("newlogs", new JSONNumber (LogBuffer.Instance.LatestLine - latestLine));
    2926
    30                         WriteJSON (_resp, result);
     27                        WebUtils.WriteJson (_context.Response, result);
    3128                }
    3229

  • binary-improvements2/MapRendering/Web/API/Null.cs

    r383 r387  
    11using System.Text;
    2 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    3 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    42
    53namespace AllocsFixes.NetConnections.Servers.Web.API {
    6         public class Null : WebAPI {
     4        public class Null : AbsWebAPI {
    75                public Null (string _name) : base(_name) {
    86                }
    97               
    10                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    11                         int _permissionLevel) {
    12                         _resp.ContentLength64 = 0;
    13                         _resp.ContentType = "text/plain";
    14                         _resp.ContentEncoding = Encoding.ASCII;
    15                         _resp.OutputStream.Write (new byte[] { }, 0, 0);
     8                public override void HandleRequest (RequestContext _context) {
     9                        _context.Response.ContentLength64 = 0;
     10                        _context.Response.ContentType = "text/plain";
     11                        _context.Response.ContentEncoding = Encoding.ASCII;
     12                        _context.Response.OutputStream.Write (new byte[] { }, 0, 0);
    1613                }
    1714        }
Note: See TracChangeset for help on using the changeset viewer.