Ignore:
Timestamp:
Jul 28, 2023, 8:42:10 PM (17 months ago)
Author:
alloc
Message:

24_29_43
Switched over to vanilla Web infrastructure

Location:
binary-improvements/MapRendering/API
Files:
1 added
14 moved

Legend:

Unmodified
Added
Removed
  • binary-improvements/MapRendering/API/ExecuteConsoleCommand.cs

    r453 r454  
    11using System;
    22using System.Net;
     3using Webserver;
     4using Webserver.WebAPI;
     5using WebCommandResult = AllocsFixes.NetConnections.Servers.Web.WebCommandResult;
    36
    4 namespace AllocsFixes.NetConnections.Servers.Web.API {
    5         public class ExecuteConsoleCommand : WebAPI {
    6                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    7                         int _permissionLevel) {
    8                         if (string.IsNullOrEmpty (_req.QueryString ["command"])) {
    9                                 _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    10                                 Web.SetResponseTextContent (_resp, "No command given");
     7namespace AllocsFixes.WebAPIs {
     8        public class ExecuteConsoleCommand : AbsWebAPI {
     9                public override void HandleRequest (RequestContext _context) {
     10                        if (string.IsNullOrEmpty (_context.Request.QueryString ["command"])) {
     11                                WebUtils.WriteText (_context.Response, "No command given", HttpStatusCode.BadRequest);
    1112                                return;
    1213                        }
    1314
    1415                        WebCommandResult.ResultType responseType =
    15                                 _req.QueryString ["raw"] != null
     16                                _context.Request.QueryString ["raw"] != null
    1617                                        ? WebCommandResult.ResultType.Raw
    17                                         : (_req.QueryString ["simple"] != null
     18                                        : (_context.Request.QueryString ["simple"] != null
    1819                                                ? WebCommandResult.ResultType.ResultOnly
    1920                                                : WebCommandResult.ResultType.Full);
    2021
    21                         string commandline = _req.QueryString ["command"];
     22                        string commandline = _context.Request.QueryString ["command"];
    2223                        string commandPart = commandline.Split (' ') [0];
    2324                        string argumentsPart = commandline.Substring (Math.Min (commandline.Length, commandPart.Length + 1));
     
    2627
    2728                        if (command == null) {
    28                                 _resp.StatusCode = (int) HttpStatusCode.NotFound;
    29                                 Web.SetResponseTextContent (_resp, "Unknown command");
     29                                WebUtils.WriteText (_context.Response, "Unknown command", HttpStatusCode.NotFound);
    3030                                return;
    3131                        }
     
    3333                        int commandPermissionLevel = GameManager.Instance.adminTools.Commands.GetCommandPermissionLevel (command.GetCommands ());
    3434
    35                         if (_permissionLevel > commandPermissionLevel) {
    36                                 _resp.StatusCode = (int) HttpStatusCode.Forbidden;
    37                                 Web.SetResponseTextContent (_resp, "You are not allowed to execute this command");
     35                        if (_context.PermissionLevel > commandPermissionLevel) {
     36                                WebUtils.WriteText (_context.Response, "You are not allowed to execute this command", HttpStatusCode.Forbidden);
    3837                                return;
    3938                        }
    4039
    41                         _resp.SendChunked = true;
    42                         WebCommandResult wcr = new WebCommandResult (commandPart, argumentsPart, responseType, _resp);
     40                        _context.Response.SendChunked = true;
     41                        WebCommandResult wcr = new WebCommandResult (commandPart, argumentsPart, responseType, _context);
    4342                        SdtdConsole.Instance.ExecuteAsync (commandline, wcr);
    4443                }
  • binary-improvements/MapRendering/API/GetAllowedCommands.cs

    r453 r454  
    1 using System.Net;
    21using AllocsFixes.JSON;
     2using Webserver;
     3using Webserver.WebAPI;
    34
    4 namespace AllocsFixes.NetConnections.Servers.Web.API {
    5         public class GetAllowedCommands : WebAPI {
    6                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    7                         int _permissionLevel) {
     5namespace AllocsFixes.WebAPIs {
     6        public class GetAllowedCommands : AbsWebAPI {
     7                public override void HandleRequest (RequestContext _context) {
    88                        JSONObject result = new JSONObject ();
    99                        JSONArray entries = new JSONArray ();
    1010                        foreach (IConsoleCommand cc in SdtdConsole.Instance.GetCommands ()) {
    1111                                int commandPermissionLevel = GameManager.Instance.adminTools.Commands.GetCommandPermissionLevel (cc.GetCommands ());
    12                                 if (_permissionLevel <= commandPermissionLevel) {
     12                                if (_context.PermissionLevel <= commandPermissionLevel) {
    1313                                        string cmd = string.Empty;
    1414                                        foreach (string s in cc.GetCommands ()) {
     
    2828                        result.Add ("commands", entries);
    2929
    30                         WriteJSON (_resp, result);
     30                        LegacyApiHelper.WriteJSON (_context.Response, result);
    3131                }
    3232
  • binary-improvements/MapRendering/API/GetAnimalsLocation.cs

    r453 r454  
    11using System.Collections.Generic;
    2 using System.Net;
    32using AllocsFixes.JSON;
    43using AllocsFixes.LiveData;
     4using Webserver;
     5using Webserver.WebAPI;
    56
    6 namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         internal class GetAnimalsLocation : WebAPI {
     7namespace AllocsFixes.WebAPIs {
     8        internal class GetAnimalsLocation : AbsWebAPI {
    89                private readonly List<EntityAnimal> animals = new List<EntityAnimal> ();
    910
    10                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    11                         int _permissionLevel) {
     11                public override void HandleRequest (RequestContext _context) {
    1212                        JSONArray animalsJsResult = new JSONArray ();
    1313
     
    3636                        }
    3737
    38                         WriteJSON (_resp, animalsJsResult);
     38                        LegacyApiHelper.WriteJSON (_context.Response, animalsJsResult);
    3939                }
    4040        }
  • binary-improvements/MapRendering/API/GetHostileLocation.cs

    r453 r454  
    11using System.Collections.Generic;
    2 using System.Net;
    32using AllocsFixes.JSON;
    43using AllocsFixes.LiveData;
     4using Webserver;
     5using Webserver.WebAPI;
    56
    6 namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         internal class GetHostileLocation : WebAPI {
     7namespace AllocsFixes.WebAPIs {
     8        internal class GetHostileLocation : AbsWebAPI {
    89                private readonly List<EntityEnemy> enemies = new List<EntityEnemy> ();
    910
    10                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    11                         int _permissionLevel) {
     11                public override void HandleRequest (RequestContext _context) {
    1212                        JSONArray hostilesJsResult = new JSONArray ();
    1313
     
    3636                        }
    3737
    38                         WriteJSON (_resp, hostilesJsResult);
     38                        LegacyApiHelper.WriteJSON (_context.Response, hostilesJsResult);
    3939                }
    4040        }
  • binary-improvements/MapRendering/API/GetLandClaims.cs

    r453 r454  
    33using AllocsFixes.JSON;
    44using AllocsFixes.PersistentData;
     5using Webserver;
     6using Webserver.Permissions;
     7using Webserver.WebAPI;
    58
    6 namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetLandClaims : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
     9namespace AllocsFixes.WebAPIs {
     10        public class GetLandClaims : AbsWebAPI {
     11                public override void HandleRequest (RequestContext _context) {
    1012                        PlatformUserIdentifierAbs requestedUserId = null;
    11                         if (_req.QueryString ["userid"] != null) {
    12                                 if (!PlatformUserIdentifierAbs.TryFromCombinedString (_req.QueryString ["userid"], out requestedUserId)) {
    13                                         _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    14                                         Web.SetResponseTextContent (_resp, "Invalid user id given");
     13                        if (_context.Request.QueryString ["userid"] != null) {
     14                                if (!PlatformUserIdentifierAbs.TryFromCombinedString (_context.Request.QueryString ["userid"], out requestedUserId)) {
     15                                        WebUtils.WriteText (_context.Response, "Invalid user id given", HttpStatusCode.BadRequest);
    1516                                        return;
    1617                                }
     
    1819
    1920                        // default user, cheap way to avoid 'null reference exception'
    20                         PlatformUserIdentifierAbs userId = _user?.UserId;
     21                        PlatformUserIdentifierAbs userId = _context.Connection?.UserId;
    2122
    22                         bool bViewAll = WebConnection.CanViewAllClaims (_permissionLevel);
     23                        bool bViewAll = PermissionUtils.CanViewAllClaims (_context.PermissionLevel);
    2324
    2425                        JSONObject result = new JSONObject ();
     
    7374                        }
    7475
    75                         WriteJSON (_resp, result);
     76                        LegacyApiHelper.WriteJSON (_context.Response, result);
    7677                }
    7778        }
  • binary-improvements/MapRendering/API/GetLog.cs

    r453 r454  
    11using System.Collections.Generic;
    2 using System.Net;
    32using AllocsFixes.JSON;
     3using Webserver;
     4using Webserver.WebAPI;
    45
    5 namespace AllocsFixes.NetConnections.Servers.Web.API {
    6         public class GetLog : WebAPI {
     6namespace AllocsFixes.WebAPIs {
     7        public class GetLog : AbsWebAPI {
    78                private const int MAX_COUNT = 1000;
    89               
    9                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    10                         int _permissionLevel) {
    11                         int count, firstLine, lastLine;
    12 
    13                         if (_req.QueryString ["count"] == null || !int.TryParse (_req.QueryString ["count"], out count)) {
     10                public override void HandleRequest (RequestContext _context) {
     11                        if (_context.Request.QueryString ["count"] == null || !int.TryParse (_context.Request.QueryString ["count"], out var count)) {
    1412                                count = 50;
    1513                        }
     
    2725                        }
    2826
    29                         if (_req.QueryString ["firstLine"] == null || !int.TryParse (_req.QueryString ["firstLine"], out firstLine)) {
     27                        if (_context.Request.QueryString ["firstLine"] == null || !int.TryParse (_context.Request.QueryString ["firstLine"], out var firstLine)) {
    3028                                if (count > 0) {
    3129                                        firstLine = LogBuffer.Instance.OldestLine;
     
    3735                        JSONObject result = new JSONObject ();
    3836
    39                         List<LogBuffer.LogEntry> logEntries = LogBuffer.Instance.GetRange (ref firstLine, count, out lastLine);
     37                        List<LogBuffer.LogEntry> logEntries = LogBuffer.Instance.GetRange (ref firstLine, count, out var lastLine);
    4038
    4139                        JSONArray entries = new JSONArray ();
    4240                        foreach (LogBuffer.LogEntry logEntry in logEntries) {
    4341                                JSONObject entry = new JSONObject ();
    44                                 entry.Add ("date", new JSONString (logEntry.date));
    45                                 entry.Add ("time", new JSONString (logEntry.time));
    46                                 entry.Add ("uptime", new JSONString (logEntry.uptime));
    47                                 entry.Add ("msg", new JSONString (logEntry.message));
    48                                 entry.Add ("trace", new JSONString (logEntry.trace));
    49                                 entry.Add ("type", new JSONString (logEntry.type.ToStringCached ()));
     42                                var logEntryTimestamp = logEntry.Timestamp;
     43                                entry.Add ("date", new JSONString ($"{logEntryTimestamp.Year:0000}-{logEntryTimestamp.Month:00}-{logEntryTimestamp.Day:00}"));
     44                                entry.Add ("time", new JSONString ($"{logEntryTimestamp.Hour:00}:{logEntryTimestamp.Minute:00}:{logEntryTimestamp.Second:00}"));
     45                                entry.Add ("uptime", new JSONString (logEntry.Uptime.ToString()));
     46                                entry.Add ("msg", new JSONString (logEntry.Message));
     47                                entry.Add ("trace", new JSONString (logEntry.Trace));
     48                                entry.Add ("type", new JSONString (logEntry.Type.ToStringCached ()));
    5049                                entries.Add (entry);
    5150                        }
     
    5554                        result.Add ("entries", entries);
    5655
    57                         WriteJSON (_resp, result);
     56                        LegacyApiHelper.WriteJSON (_context.Response, result);
    5857                }
    5958        }
  • binary-improvements/MapRendering/API/GetPlayerInventories.cs

    r453 r454  
    11using System.Collections.Generic;
    2 using System.Net;
    32using AllocsFixes.JSON;
    43using AllocsFixes.PersistentData;
     4using Webserver;
     5using Webserver.WebAPI;
    56
    6 namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetPlayerInventories : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
    10                         GetPlayerInventory.GetInventoryArguments (_req, out bool showIconColor, out bool showIconName);
     7namespace AllocsFixes.WebAPIs {
     8        public class GetPlayerInventories : AbsWebAPI {
     9                public override void HandleRequest (RequestContext _context) {
     10                        GetPlayerInventory.GetInventoryArguments (_context, out bool showIconColor, out bool showIconName);
    1111
    1212                        JSONArray AllInventoriesResult = new JSONArray ();
     
    2424                        }
    2525
    26                         WriteJSON (_resp, AllInventoriesResult);
     26                        LegacyApiHelper.WriteJSON (_context.Response, AllInventoriesResult);
    2727                }
    2828        }
  • binary-improvements/MapRendering/API/GetPlayerInventory.cs

    r453 r454  
    33using AllocsFixes.JSON;
    44using AllocsFixes.PersistentData;
     5using Webserver;
     6using Webserver.WebAPI;
    57
    6 namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetPlayerInventory : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
    10                         if (_req.QueryString ["userid"] == null) {
    11                                 _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    12                                 Web.SetResponseTextContent (_resp, "No user id given");
     8namespace AllocsFixes.WebAPIs {
     9        public class GetPlayerInventory : AbsWebAPI {
     10                public override void HandleRequest (RequestContext _context) {
     11                        if (_context.Request.QueryString ["userid"] == null) {
     12                                WebUtils.WriteText (_context.Response, "No user id given", HttpStatusCode.BadRequest);
    1313                                return;
    1414                        }
    1515
    16                         string userIdString = _req.QueryString ["userid"];
     16                        string userIdString = _context.Request.QueryString ["userid"];
    1717                        if (!PlatformUserIdentifierAbs.TryFromCombinedString (userIdString, out PlatformUserIdentifierAbs userId)) {
    18                                 _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    19                                 Web.SetResponseTextContent (_resp, "Invalid user id given");
     18                                WebUtils.WriteText (_context.Response, "Invalid user id given", HttpStatusCode.BadRequest);
    2019                                return;
    2120                        }
     
    2322                        Player p = PersistentContainer.Instance.Players.GetByUserId (userId);
    2423                        if (p == null) {
    25                                 _resp.StatusCode = (int) HttpStatusCode.NotFound;
    26                                 Web.SetResponseTextContent (_resp, "Unknown user id given");
     24                                WebUtils.WriteText (_context.Response, "Unknown user id given", HttpStatusCode.NotFound);
    2725                                return;
    2826                        }
    2927
    30                         GetInventoryArguments (_req, out bool showIconColor, out bool showIconName);
     28                        GetInventoryArguments (_context, out bool showIconColor, out bool showIconName);
    3129
    3230                        JSONObject result = DoPlayer (p, showIconColor, showIconName);
    3331
    34                         WriteJSON (_resp, result);
     32                        LegacyApiHelper.WriteJSON (_context.Response, result);
    3533                }
    3634
    37                 internal static void GetInventoryArguments (HttpListenerRequest _req, out bool _showIconColor, out bool _showIconName) {
    38                         if (_req.QueryString ["showiconcolor"] == null || !bool.TryParse (_req.QueryString ["showiconcolor"], out _showIconColor)) {
     35                internal static void GetInventoryArguments (RequestContext _context, out bool _showIconColor, out bool _showIconName) {
     36                        if (_context.Request.QueryString ["showiconcolor"] == null || !bool.TryParse (_context.Request.QueryString ["showiconcolor"], out _showIconColor)) {
    3937                                _showIconColor = true;
    4038                        }
    4139                       
    42                         if (_req.QueryString ["showiconname"] == null || !bool.TryParse (_req.QueryString ["showiconname"], out _showIconName)) {
     40                        if (_context.Request.QueryString ["showiconname"] == null || !bool.TryParse (_context.Request.QueryString ["showiconname"], out _showIconName)) {
    4341                                _showIconName = true;
    4442                        }
  • binary-improvements/MapRendering/API/GetPlayerList.cs

    r453 r454  
    22using System.Collections.Generic;
    33using System.Linq;
    4 using System.Net;
    54using System.Text.RegularExpressions;
    65using AllocsFixes.JSON;
    76using AllocsFixes.PersistentData;
    8 
    9 namespace AllocsFixes.NetConnections.Servers.Web.API {
    10         public class GetPlayerList : WebAPI {
     7using Webserver;
     8using Webserver.Permissions;
     9using Webserver.WebAPI;
     10
     11namespace AllocsFixes.WebAPIs {
     12        public class GetPlayerList : AbsWebAPI {
    1113                private static readonly Regex numberFilterMatcher =
    1214                        new Regex (@"^(>=|=>|>|<=|=<|<|==|=)?\s*([0-9]+(\.[0-9]*)?)$");
     
    1618#endif
    1719
    18                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    19                         int _permissionLevel) {
     20                public override void HandleRequest (RequestContext _context) {
    2021                        AdminTools admTools = GameManager.Instance.adminTools;
    21                         PlatformUserIdentifierAbs userId = _user?.UserId;
    22 
    23                         bool bViewAll = WebConnection.CanViewAllPlayers (_permissionLevel);
     22                        PlatformUserIdentifierAbs userId = _context.Connection?.UserId;
     23
     24                        bool bViewAll = PermissionUtils.CanViewAllPlayers (_context.PermissionLevel);
    2425
    2526                        // 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)
    2627
    2728                        int rowsPerPage = 25;
    28                         if (_req.QueryString ["rowsperpage"] != null) {
    29                                 int.TryParse (_req.QueryString ["rowsperpage"], out rowsPerPage);
     29                        if (_context.Request.QueryString ["rowsperpage"] != null) {
     30                                int.TryParse (_context.Request.QueryString ["rowsperpage"], out rowsPerPage);
    3031                        }
    3132
    3233                        int page = 0;
    33                         if (_req.QueryString ["page"] != null) {
    34                                 int.TryParse (_req.QueryString ["page"], out page);
     34                        if (_context.Request.QueryString ["page"] != null) {
     35                                int.TryParse (_context.Request.QueryString ["page"], out page);
    3536                        }
    3637
     
    8384                        IEnumerable<JSONObject> list = playerList;
    8485
    85                         foreach (string key in _req.QueryString.AllKeys) {
     86                        foreach (string key in _context.Request.QueryString.AllKeys) {
    8687                                if (!string.IsNullOrEmpty (key) && key.StartsWith ("filter[")) {
    8788                                        string filterCol = key.Substring (key.IndexOf ('[') + 1);
    8889                                        filterCol = filterCol.Substring (0, filterCol.Length - 1);
    89                                         string filterVal = _req.QueryString.Get (key).Trim ();
     90                                        string filterVal = _context.Request.QueryString.Get (key).Trim ();
    9091
    9192                                        list = ExecuteFilter (list, filterCol, filterVal);
     
    9596                        int totalAfterFilter = list.Count ();
    9697
    97                         foreach (string key in _req.QueryString.AllKeys) {
     98                        foreach (string key in _context.Request.QueryString.AllKeys) {
    9899                                if (!string.IsNullOrEmpty (key) && key.StartsWith ("sort[")) {
    99100                                        string sortCol = key.Substring (key.IndexOf ('[') + 1);
    100101                                        sortCol = sortCol.Substring (0, sortCol.Length - 1);
    101                                         string sortVal = _req.QueryString.Get (key);
     102                                        string sortVal = _context.Request.QueryString.Get (key);
    102103
    103104                                        list = ExecuteSort (list, sortCol, sortVal == "0");
     
    120121                        result.Add ("players", playersJsResult);
    121122
    122                         WriteJSON (_resp, result);
     123                        LegacyApiHelper.WriteJSON (_context.Response, result);
    123124                }
    124125
  • binary-improvements/MapRendering/API/GetPlayersLocation.cs

    r453 r454  
    11using System.Collections.Generic;
    2 using System.Net;
    32using AllocsFixes.JSON;
    43using AllocsFixes.PersistentData;
     4using Webserver;
     5using Webserver.Permissions;
     6using Webserver.WebAPI;
    57
    6 namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetPlayersLocation : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
     8namespace AllocsFixes.WebAPIs {
     9        public class GetPlayersLocation : AbsWebAPI {
     10                public override void HandleRequest (RequestContext _context) {
    1011                        AdminTools admTools = GameManager.Instance.adminTools;
    11                         PlatformUserIdentifierAbs userId = _user?.UserId;
     12                        PlatformUserIdentifierAbs userId = _context.Connection?.UserId;
    1213
    1314                        bool listOffline = false;
    14                         if (_req.QueryString ["offline"] != null) {
    15                                 bool.TryParse (_req.QueryString ["offline"], out listOffline);
     15                        if (_context.Request.QueryString ["offline"] != null) {
     16                                bool.TryParse (_context.Request.QueryString ["offline"], out listOffline);
    1617                        }
    1718
    18                         bool bViewAll = WebConnection.CanViewAllPlayers (_permissionLevel);
     19                        bool bViewAll = PermissionUtils.CanViewAllPlayers (_context.PermissionLevel);
    1920
    2021                        JSONArray playersJsResult = new JSONArray ();
     
    5758                        }
    5859
    59                         WriteJSON (_resp, playersJsResult);
     60                        LegacyApiHelper.WriteJSON (_context.Response, playersJsResult);
    6061                }
    6162        }
  • binary-improvements/MapRendering/API/GetPlayersOnline.cs

    r453 r454  
    11using System.Collections.Generic;
    2 using System.Net;
    32using AllocsFixes.JSON;
    43using AllocsFixes.PersistentData;
     4using Webserver;
     5using Webserver.WebAPI;
    56
    6 namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetPlayersOnline : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
     7namespace AllocsFixes.WebAPIs {
     8        public class GetPlayersOnline : AbsWebAPI {
     9                public override void HandleRequest (RequestContext _context) {
    1010                        JSONArray players = new JSONArray ();
    1111
     
    4444                        }
    4545
    46                         WriteJSON (_resp, players);
     46                        LegacyApiHelper.WriteJSON (_context.Response, players);
    4747                }
    4848        }
  • binary-improvements/MapRendering/API/GetServerInfo.cs

    r453 r454  
    11using System;
    2 using System.Net;
    32using AllocsFixes.JSON;
     3using Webserver;
     4using Webserver.WebAPI;
    45
    5 namespace AllocsFixes.NetConnections.Servers.Web.API {
    6         public class GetServerInfo : WebAPI {
    7                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    8                         int _permissionLevel) {
     6namespace AllocsFixes.WebAPIs {
     7        public class GetServerInfo : AbsWebAPI {
     8                public override void HandleRequest (RequestContext _context) {
    99                        JSONObject serverInfo = new JSONObject ();
    1010
     
    4242
    4343
    44                         WriteJSON (_resp, serverInfo);
     44                        LegacyApiHelper.WriteJSON (_context.Response, serverInfo);
    4545                }
    4646        }
  • binary-improvements/MapRendering/API/GetStats.cs

    r453 r454  
    1 using System.Net;
    21using AllocsFixes.JSON;
    32using AllocsFixes.LiveData;
     3using Webserver;
     4using Webserver.WebAPI;
    45
    5 namespace AllocsFixes.NetConnections.Servers.Web.API {
    6         public class GetStats : WebAPI {
    7                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    8                         int _permissionLevel) {
     6namespace AllocsFixes.WebAPIs {
     7        public class GetStats : AbsWebAPI {
     8                public override void HandleRequest (RequestContext _context) {
    99                        JSONObject result = new JSONObject ();
    1010
     
    1919                        result.Add ("animals", new JSONNumber (Animals.Instance.GetCount ()));
    2020
    21                         WriteJSON (_resp, result);
     21                        LegacyApiHelper.WriteJSON (_context.Response, result);
    2222                }
    2323
  • binary-improvements/MapRendering/API/GetWebUIUpdates.cs

    r453 r454  
    1 using System.Net;
    21using AllocsFixes.JSON;
    32using AllocsFixes.LiveData;
     3using Webserver;
     4using Webserver.WebAPI;
    45
    5 namespace AllocsFixes.NetConnections.Servers.Web.API {
    6         public class GetWebUIUpdates : WebAPI {
    7                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    8                         int _permissionLevel) {
     6namespace AllocsFixes.WebAPIs {
     7        public class GetWebUIUpdates : AbsWebAPI {
     8                public override void HandleRequest (RequestContext _context) {
    99                        int latestLine;
    10                         if (_req.QueryString ["latestLine"] == null ||
    11                             !int.TryParse (_req.QueryString ["latestLine"], out latestLine)) {
     10                        if (_context.Request.QueryString ["latestLine"] == null ||
     11                            !int.TryParse (_context.Request.QueryString ["latestLine"], out latestLine)) {
    1212                                latestLine = 0;
    1313                        }
     
    2727                        result.Add ("newlogs", new JSONNumber (LogBuffer.Instance.LatestLine - latestLine));
    2828
    29                         WriteJSON (_resp, result);
     29                        LegacyApiHelper.WriteJSON (_context.Response, result);
    3030                }
    3131
Note: See TracChangeset for help on using the changeset viewer.