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
Files:
3 added
14 deleted
3 edited
15 moved

Legend:

Unmodified
Added
Removed

  • binary-improvements/MapRendering/API.cs

    r420 r454  
    1 using AllocsFixes.NetConnections.Servers.Web;
    2 using AllocsFixes.NetConnections.Servers.Web.Handlers;
     1using System;
     2using System.IO;
     3using Webserver;
     4using Webserver.FileCache;
     5using Webserver.UrlHandlers;
    36
    47namespace AllocsFixes {
    58        public class API : IModApi {
    6                 private Web webInstance;
     9                private Mod modInstance;
    710               
    811                public void InitMod (Mod _modInstance) {
    9                         ModEvents.GameStartDone.RegisterHandler (GameStartDone);
    10                         ModEvents.GameShutdown.RegisterHandler (GameShutdown);
     12                        modInstance = _modInstance;
     13
     14                        Web.ServerInitialized += _web => {
     15                                try {
     16                                        const string legacyModUrl = "/legacymap";
     17                                        const string legacyFilesFoldername = "webserver_legacy";
     18                                        string legacyFilePath = $"{modInstance.Path}/{legacyFilesFoldername}";
     19                               
     20                                        if (!Directory.Exists (legacyFilePath)) {
     21                                                Log.Out ($"Legacy webmod feature not started (folder \"{legacyFilesFoldername}\" not found in Allocs_WebAndMapRendering mod folder)");
     22                                                return;
     23                                        }
     24
     25                                        // TODO: Read from config
     26                                        bool useStaticCache = false;
     27
     28                                        _web.RegisterPathHandler ("/legacymap.htm", new SimpleRedirectHandler ($"{legacyModUrl}/index.html"));
     29                                        _web.RegisterPathHandler ($"{legacyModUrl}/", new StaticHandler (legacyFilePath, useStaticCache ? (AbstractCache) new SimpleCache () : new DirectAccess (), false));
     30
     31                                        int webPort = GamePrefs.GetInt (EnumUtils.Parse<EnumGamePrefs> (nameof (EnumGamePrefs.WebDashboardPort)));
     32                                        Log.Out ($"Started legacy webmod feature on port {webPort}, local adress {legacyModUrl}");
     33                                } catch (Exception e) {
     34                                        Log.Out ("Error in Web.ctor: " + e);
     35                                }
     36                        };
    1137                }
    1238
    13                 private void GameStartDone () {
    14                         // ReSharper disable once ObjectCreationAsStatement
    15                         if (!ConnectionManager.Instance.IsServer) {
    16                                 return;
    17                         }
    18                        
    19                         webInstance = new Web ();
    20                         LogBuffer.Init ();
     39                // public static void SetResponseTextContent (HttpListenerResponse _context.Response, string _text) {
     40                //      byte[] buf = Encoding.UTF8.GetBytes (_text);
     41                //      _context.Response.ContentLength64 = buf.Length;
     42                //      _context.Response.ContentType = "text/html";
     43                //      _context.Response.ContentEncoding = Encoding.UTF8;
     44                //      _context.Response.OutputStream.Write (buf, 0, buf.Length);
     45                // }
    2146
    22                         if (ItemIconHandler.Instance != null) {
    23                                 ItemIconHandler.Instance.LoadIcons ();
    24                         }
    25                 }
    26 
    27                 private void GameShutdown () {
    28                         webInstance?.Shutdown ();
    29                 }
     47               
    3048        }
    3149}

  • 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

  • binary-improvements/MapRendering/ModInfo.xml

    r448 r454  
    55                <Description value="Render the game map to image map tiles as it is uncovered" />
    66                <Author value="Christian 'Alloc' Illy" />
    7                 <Version value="42" />
     7                <Version value="43" />
    88                <Website value="http://7dtd.illy.bz" />
    99        </ModInfo>

  • binary-improvements/MapRendering/WebAndMapRendering.csproj

    r450 r454  
    1111    <AssemblyName>AllocsWeb</AssemblyName>
    1212    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
     13    <Nullable>warnings</Nullable>
     14    <LangVersion>9</LangVersion>
    1315  </PropertyGroup>
    1416  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    … …  
    5557      <Private>False</Private>
    5658    </Reference>
     59    <Reference Include="SpaceWizards.HttpListener">
     60      <HintPath>..\7dtd-binaries\SpaceWizards.HttpListener.dll</HintPath>
     61      <Private>False</Private>
     62    </Reference>
    5763    <Reference Include="UnityEngine">
    5864      <HintPath>..\7dtd-binaries\UnityEngine.dll</HintPath>
    … …  
    8995  </ItemGroup>
    9096  <ItemGroup>
     97    <Compile Include="API\ExecuteConsoleCommand.cs" />
     98    <Compile Include="API\GetAllowedCommands.cs" />
     99    <Compile Include="API\GetAnimalsLocation.cs" />
     100    <Compile Include="API\GetHostileLocation.cs" />
     101    <Compile Include="API\GetLandClaims.cs" />
     102    <Compile Include="API\GetLog.cs" />
     103    <Compile Include="API\GetPlayerInventories.cs" />
     104    <Compile Include="API\GetPlayerInventory.cs" />
     105    <Compile Include="API\GetPlayerList.cs" />
     106    <Compile Include="API\GetPlayersLocation.cs" />
     107    <Compile Include="API\GetPlayersOnline.cs" />
     108    <Compile Include="API\GetServerInfo.cs" />
     109    <Compile Include="API\GetStats.cs" />
     110    <Compile Include="API\GetWebUIUpdates.cs" />
    91111    <Compile Include="AssemblyInfo.cs" />
    92112    <Compile Include="API.cs" />
    93     <Compile Include="Web\API\GetAnimalsLocation.cs" />
    94     <Compile Include="Web\API\GetHostileLocation.cs" />
    95     <Compile Include="Web\API\Null.cs" />
    96     <Compile Include="Web\SSE\EventLog.cs" />
    97     <Compile Include="Web\SSE\SseHandler.cs" />
    98     <Compile Include="Web\SSE\EventBase.cs" />
    99     <Compile Include="Web\Web.cs" />
    100     <Compile Include="Web\MimeType.cs" />
    101     <Compile Include="Web\API\GetPlayersOnline.cs" />
    102     <Compile Include="Web\API\WebAPI.cs" />
    103     <Compile Include="Web\API\GetPlayersLocation.cs" />
    104     <Compile Include="Web\API\GetPlayerInventory.cs" />
    105     <Compile Include="Web\API\GetLandClaims.cs" />
    106     <Compile Include="Commands\webstat.cs" />
    107     <Compile Include="Web\API\GetStats.cs" />
    108     <Compile Include="Web\WebConnection.cs" />
    109     <Compile Include="Web\OpenID.cs" />
    110     <Compile Include="Web\ConnectionHandler.cs" />
    111     <Compile Include="Web\WebPermissions.cs" />
    112     <Compile Include="Web\Handlers\ApiHandler.cs" />
    113     <Compile Include="Web\Handlers\ItemIconHandler.cs" />
    114     <Compile Include="Web\Handlers\PathHandler.cs" />
    115     <Compile Include="Web\Handlers\SimpleRedirectHandler.cs" />
    116     <Compile Include="Web\Handlers\StaticHandler.cs" />
    117     <Compile Include="Web\Handlers\SessionHandler.cs" />
    118     <Compile Include="Web\API\ExecuteConsoleCommand.cs" />
    119     <Compile Include="Commands\ReloadWebPermissions.cs" />
    120     <Compile Include="Web\Handlers\UserStatusHandler.cs" />
    121     <Compile Include="Commands\WebTokens.cs" />
    122     <Compile Include="Commands\WebPermissionsCmd.cs" />
    123     <Compile Include="Web\LogBuffer.cs" />
    124     <Compile Include="Web\API\GetLog.cs" />
    125     <Compile Include="Web\API\GetWebUIUpdates.cs" />
    126     <Compile Include="Web\API\GetServerInfo.cs" />
    127     <Compile Include="Web\API\GetPlayerList.cs" />
    128     <Compile Include="Web\WebCommandResult.cs" />
    129     <Compile Include="Web\API\GetAllowedCommands.cs" />
    130     <Compile Include="Web\API\GetPlayerInventories.cs" />
     113    <Compile Include="LegacyApiHelper.cs" />
     114    <Compile Include="SteamLoginApi.cs" />
     115    <Compile Include="WebCommandResult.cs" />
    131116  </ItemGroup>
    132117  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
    … …  
    142127      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    143128    </None>
    144     <None Include="steam-intermediate.cer">
    145       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    146     </None>
    147     <None Include="steam-rootca.cer">
    148       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    149     </None>
    150129  </ItemGroup>
    151130</Project>

  • binary-improvements/MapRendering/WebCommandResult.cs

    r453 r454  
    22using System.Collections.Generic;
    33using System.IO;
    4 using System.Net;
    54using System.Net.Sockets;
    65using System.Text;
    76using System.Threading;
    87using AllocsFixes.JSON;
    9 using AllocsFixes.NetConnections.Servers.Web.API;
    108using UnityEngine;
     9using Webserver;
    1110
    1211namespace AllocsFixes.NetConnections.Servers.Web {
    … …  
    2423                private readonly string parameters;
    2524
    26                 private readonly HttpListenerResponse response;
     25                private readonly RequestContext context;
    2726                private readonly ResultType responseType;
    2827
    29                 public WebCommandResult (string _command, string _parameters, ResultType _responseType,
    30                         HttpListenerResponse _response) {
     28                public WebCommandResult (string _command, string _parameters, ResultType _resultType, RequestContext _context) {
    3129                        Interlocked.Increment (ref handlingCount);
    3230                        Interlocked.Increment (ref currentHandlers);
    3331
    34                         response = _response;
     32                        context = _context;
    3533                        command = _command;
    3634                        parameters = _parameters;
    37                         responseType = _responseType;
     35                        responseType = _resultType;
    3836                }
    3937
    … …  
    4745
    4846                        try {
    49                                 response.SendChunked = false;
     47                                context.Response.SendChunked = false;
    5048
    5149                                if (responseType == ResultType.Raw) {
    52                                         WebAPI.WriteText (response, sb.ToString ());
     50                                        WebUtils.WriteText (context.Response, sb.ToString ());
    5351                                } else {
    5452                                        JSONNode result;
    … …  
    6563                                        }
    6664
    67                                         WebAPI.WriteJSON (response, result);
     65                                        LegacyApiHelper.WriteJSON (context.Response, result);
    6866                                }
    6967                        } catch (IOException e) {
    7068                                if (e.InnerException is SocketException) {
    71                                         Log.Out ("Error in WebCommandResult.SendLines(): Remote host closed connection: " +
    72                                                  e.InnerException.Message);
     69                                        Log.Out ("Error in WebCommandResult.SendLines(): Remote host closed connection: " + e.InnerException.Message);
    7370                                } else {
    7471                                        Log.Out ("Error (IO) in WebCommandResult.SendLines(): " + e);
    … …  
    7774                                Log.Out ("Error in WebCommandResult.SendLines(): " + e);
    7875                        } finally {
    79                                 if (response != null) {
    80                                         response.Close ();
    81                                 }
     76                                context.Response?.Close ();
    8277
    83 //                              msw.Stop ();
     78                                //                              msw.Stop ();
    8479//                              if (GamePrefs.GetInt (EnumGamePrefs.HideCommandExecutionLog) < 1) {
    8580//                                      totalHandlingTime += msw.ElapsedMicroseconds;
Note: See TracChangeset for help on using the changeset viewer.