Ignore:
Timestamp:
Sep 4, 2018, 1:00:48 PM (6 years ago)
Author:
alloc
Message:

Code style cleanup (mostly whitespace changes, enforcing braces, using cleanup)

Location:
binary-improvements/MapRendering/Web/Handlers
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • binary-improvements/MapRendering/Web/Handlers/ApiHandler.cs

    r279 r325  
    1 using AllocsFixes.NetConnections.Servers.Web.API;
    21using System;
    32using System.Collections.Generic;
    4 using System.IO;
    53using System.Net;
    64using System.Reflection;
    7 using System.Threading;
     5using AllocsFixes.NetConnections.Servers.Web.API;
    86
    9 namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    10 {
     7namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    118        public class ApiHandler : PathHandler {
    12                 private string staticPart;
    13                 private Dictionary<String, WebAPI> apis = new Dictionary<string, WebAPI> ();
     9                private readonly Dictionary<string, WebAPI> apis = new Dictionary<string, WebAPI> ();
     10                private readonly string staticPart;
    1411
    1512                public ApiHandler (string staticPart, string moduleName = null) : base (moduleName) {
    … …  
    1714
    1815                        foreach (Type t in Assembly.GetExecutingAssembly ().GetTypes ()) {
    19                                 if (!t.IsAbstract && t.IsSubclassOf (typeof(WebAPI))) {
     16                                if (!t.IsAbstract && t.IsSubclassOf (typeof (WebAPI))) {
    2017                                        ConstructorInfo ctor = t.GetConstructor (new Type [0]);
    2118                                        if (ctor != null) {
    22                                                 WebAPI apiInstance = (WebAPI)ctor.Invoke (new object [0]);
     19                                                WebAPI apiInstance = (WebAPI) ctor.Invoke (new object [0]);
    2320                                                addApi (t.Name.ToLower (), apiInstance);
    2421                                        }
    … …  
    2623                        }
    2724
    28             // Add dummy types
    29             Type dummy_t = typeof (API.Null);
    30             ConstructorInfo dummy_ctor = dummy_t.GetConstructor (new Type [0]);
    31             if (dummy_ctor != null) {
    32                 WebAPI dummy_apiInstance = (WebAPI)dummy_ctor.Invoke (new object[0]);
     25                        // Add dummy types
     26                        Type dummy_t = typeof (Null);
     27                        ConstructorInfo dummy_ctor = dummy_t.GetConstructor (new Type [0]);
     28                        if (dummy_ctor != null) {
     29                                WebAPI dummy_apiInstance = (WebAPI) dummy_ctor.Invoke (new object[0]);
    3330
    34                 // Permissions that don't map to a real API
    35                 addApi("viewallclaims", dummy_apiInstance);
    36                 addApi("viewallplayers", dummy_apiInstance);
    37             }
     31                                // Permissions that don't map to a real API
     32                                addApi ("viewallclaims", dummy_apiInstance);
     33                                addApi ("viewallplayers", dummy_apiInstance);
     34                        }
    3835                }
    3936
    … …  
    4340                }
    4441
    45                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel) {
     42                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
     43                        int permissionLevel) {
    4644                        string apiName = req.Url.AbsolutePath.Remove (0, staticPart.Length);
    4745                        if (!AuthorizeForCommand (apiName, user, permissionLevel)) {
    48                                 resp.StatusCode = (int)HttpStatusCode.Forbidden;
     46                                resp.StatusCode = (int) HttpStatusCode.Forbidden;
    4947                                if (user != null) {
    5048                                        //Log.Out ("ApiHandler: user '{0}' not allowed to execute '{1}'", user.SteamID, apiName);
    51                                 } else {
    52                                         //Log.Out ("ApiHandler: unidentified user from '{0}' not allowed to execute '{1}'", req.RemoteEndPoint.Address, apiName);
    5349                                }
     50
    5451                                return;
    55                         } else {
    56                                 foreach (KeyValuePair<string, WebAPI> kvp in apis) {
    57                                         if (apiName.StartsWith (kvp.Key)) {
    58                                                 try {
    59                                                         kvp.Value.HandleRequest (req, resp, user, permissionLevel);
    60                                                         return;
    61                                                 } catch (Exception e) {
    62                                                         Log.Error ("Error in ApiHandler.HandleRequest(): Handler {0} threw an exception:", kvp.Key);
    63                                                         Log.Exception (e);
    64                                                         resp.StatusCode = (int)HttpStatusCode.InternalServerError;
    65                                                         return;
    66                                                 }
     52                        }
     53
     54                        foreach (KeyValuePair<string, WebAPI> kvp in apis) {
     55                                if (apiName.StartsWith (kvp.Key)) {
     56                                        try {
     57                                                kvp.Value.HandleRequest (req, resp, user, permissionLevel);
     58                                                return;
     59                                        } catch (Exception e) {
     60                                                Log.Error ("Error in ApiHandler.HandleRequest(): Handler {0} threw an exception:", kvp.Key);
     61                                                Log.Exception (e);
     62                                                resp.StatusCode = (int) HttpStatusCode.InternalServerError;
     63                                                return;
    6764                                        }
    6865                                }
    6966                        }
    70        
     67
    7168                        Log.Out ("Error in ApiHandler.HandleRequest(): No handler found for API \"" + apiName + "\"");
    72                         resp.StatusCode = (int)HttpStatusCode.NotFound;
     69                        resp.StatusCode = (int) HttpStatusCode.NotFound;
    7370                }
    7471
    … …  
    7673                        return WebPermissions.Instance.ModuleAllowedWithLevel ("webapi." + apiName, permissionLevel);
    7774                }
    78 
    7975        }
    80 
    8176}
    82 

  • binary-improvements/MapRendering/Web/Handlers/ItemIconHandler.cs

    r306 r325  
    11using System;
    22using System.Collections.Generic;
     3using System.IO;
    34using System.Net;
    4 using System.Threading;
     5using UnityEngine;
     6using Object = UnityEngine.Object;
    57
    6 using UnityEngine;
    7 using System.IO;
     8namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
     9        public class ItemIconHandler : PathHandler {
     10                private readonly Dictionary<string, byte[]> icons = new Dictionary<string, byte[]> ();
     11                private readonly bool logMissingFiles;
    812
    9 namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    10 {
    11         public class ItemIconHandler : PathHandler {
    12                 private static ItemIconHandler instance = null;
    13                 public static ItemIconHandler Instance {
    14                         get { return instance; }
     13                private readonly string staticPart;
     14                private bool loaded;
     15
     16                static ItemIconHandler () {
     17                        Instance = null;
    1518                }
    1619
    17                 private string staticPart;
    18                 private bool logMissingFiles;
    19                 private Dictionary<string, byte[]> icons = new Dictionary<string, byte[]> ();
    20                 private bool loaded = false;
    21 
    22                 public ItemIconHandler (string staticPart, bool logMissingFiles, string moduleName = null) : base(moduleName) {
     20                public ItemIconHandler (string staticPart, bool logMissingFiles, string moduleName = null) : base (moduleName) {
    2321                        this.staticPart = staticPart;
    2422                        this.logMissingFiles = logMissingFiles;
    25                         ItemIconHandler.instance = this;
     23                        Instance = this;
    2624                }
    2725
    28                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel) {
     26                public static ItemIconHandler Instance { get; private set; }
     27
     28                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
     29                        int permissionLevel) {
    2930                        if (!loaded) {
    30                                 resp.StatusCode = (int)HttpStatusCode.InternalServerError;
     31                                resp.StatusCode = (int) HttpStatusCode.InternalServerError;
    3132                                Log.Out ("Web:IconHandler: Icons not loaded");
    3233                                return;
    … …  
    4445                                resp.OutputStream.Write (itemIconData, 0, itemIconData.Length);
    4546                        } else {
    46                                 resp.StatusCode = (int)HttpStatusCode.NotFound;
     47                                resp.StatusCode = (int) HttpStatusCode.NotFound;
    4748                                if (logMissingFiles) {
    4849                                        Log.Out ("Web:IconHandler:FileNotFound: \"" + req.Url.AbsolutePath + "\" ");
    4950                                }
    50                                 return;
    5151                        }
    5252                }
    … …  
    6666                                        return false;
    6767                                }
     68
    6869                                DynamicUIAtlas atlas = atlasObj.GetComponent<DynamicUIAtlas> ();
    6970                                if (atlas == null) {
    … …  
    7879                                Texture2D atlasTex;
    7980
    80                                 if (!DynamicUIAtlasTools.ReadPrebakedAtlasDescriptor (textureResourceName, out sprites, out elementWidth, out elementHeight)) {
     81                                if (!DynamicUIAtlasTools.ReadPrebakedAtlasDescriptor (textureResourceName, out sprites,
     82                                        out elementWidth, out elementHeight)) {
    8183                                        SdtdConsole.Instance.Output ("Web:IconHandler: Could not read dynamic atlas descriptor");
    8284                                        return false;
    … …  
    98100                                                                tintedIcons.Add (name, new List<Color> ());
    99101                                                        }
     102
    100103                                                        List<Color> list = tintedIcons [name];
    101104                                                        list.Add (tintColor);
    … …  
    108111                                        string name = data.name;
    109112                                        Texture2D tex = new Texture2D (data.width, data.height, TextureFormat.ARGB32, false);
    110                                         tex.SetPixels (atlasTex.GetPixels (data.x, atlasTex.height - data.height - data.y, data.width, data.height));
     113                                        tex.SetPixels (atlasTex.GetPixels (data.x, atlasTex.height - data.height - data.y, data.width,
     114                                                data.height));
    111115
    112116                                        AddIcon (name, tex, tintedIcons);
    113117
    114                                         UnityEngine.Object.Destroy (tex);
     118                                        Object.Destroy (tex);
    115119                                }
    116                                 Resources.UnloadAsset(atlasTex);
     120
     121                                Resources.UnloadAsset (atlasTex);
    117122
    118123                                // Load icons from mods
    … …  
    131136                                                                                        }
    132137
    133                                                                                         UnityEngine.Object.Destroy (tex);
     138                                                                                        Object.Destroy (tex);
    134139                                                                                }
    135140                                                                        }
    … …  
    168173                                                icons [tintedName] = tintedTex.EncodeToPNG ();
    169174
    170                                                 UnityEngine.Object.Destroy (tintedTex);
     175                                                Object.Destroy (tintedTex);
    171176                                        }
    172177                                }
    173178                        }
    174179                }
    175 
    176180        }
    177181}
    178 

  • binary-improvements/MapRendering/Web/Handlers/PathHandler.cs

    r279 r325  
    1 using System;
    21using System.Net;
    32
    4 namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    5 {
    6         public abstract class PathHandler
    7         {
    8                 private string moduleName = null;
     3namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
     4        public abstract class PathHandler {
     5                private readonly string moduleName;
     6
     7                protected PathHandler (string _moduleName, int _defaultPermissionLevel = 0) {
     8                        moduleName = _moduleName;
     9                        WebPermissions.Instance.AddKnownModule (_moduleName, _defaultPermissionLevel);
     10                }
     11
    912                public string ModuleName {
    1013                        get { return moduleName; }
    1114                }
    1215
    13                 protected PathHandler (string _moduleName, int _defaultPermissionLevel = 0) {
    14                         this.moduleName = _moduleName;
    15                         WebPermissions.Instance.AddKnownModule (_moduleName, _defaultPermissionLevel);
    16                 }
    17 
    18                 public abstract void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel);
     16                public abstract void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
     17                        int permissionLevel);
    1918
    2019                public bool IsAuthorizedForHandler (WebConnection user, int permissionLevel) {
    2120                        if (moduleName != null) {
    2221                                return WebPermissions.Instance.ModuleAllowedWithLevel (moduleName, permissionLevel);
    23                         } else {
    24                                 return true;
    2522                        }
     23
     24                        return true;
    2625                }
    2726        }
    2827}
    29 

  • binary-improvements/MapRendering/Web/Handlers/SessionHandler.cs

    r311 r325  
    1 using System;
    2 using System.Collections.Generic;
    31using System.IO;
    42using System.Net;
    53using System.Text;
    6 using System.Threading;
    74
    8 namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    9 {
     5namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    106        public class SessionHandler : PathHandler {
    11                 private string staticPart;
    12                 private Web parent;
    13                 private string header = "";
    14                 private string footer = "";
     7                private readonly string footer = "";
     8                private readonly string header = "";
     9                private readonly Web parent;
     10                private readonly string staticPart;
    1511
    16                 public SessionHandler (string _staticPart, string _dataFolder, Web _parent, string moduleName = null) : base(moduleName) {
    17                         this.staticPart = _staticPart;
    18                         this.parent = _parent;
     12                public SessionHandler (string _staticPart, string _dataFolder, Web _parent, string moduleName = null) :
     13                        base (moduleName) {
     14                        staticPart = _staticPart;
     15                        parent = _parent;
    1916
    2017                        if (File.Exists (_dataFolder + "/sessionheader.tmpl")) {
    … …  
    2724                }
    2825
    29                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel) {
     26                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
     27                        int permissionLevel) {
    3028                        string subpath = req.Url.AbsolutePath.Remove (0, staticPart.Length);
    3129
    … …  
    3735                                        resp.Redirect ("/static/index.html");
    3836                                        return;
    39                                 } else {
    40                                         result.Append ("<h1>Login failed, <a href=\"/static/index.html\">click to return to main page</a>.</h1>");
    4137                                }
     38
     39                                result.Append (
     40                                        "<h1>Login failed, <a href=\"/static/index.html\">click to return to main page</a>.</h1>");
    4241                        } else if (subpath.StartsWith ("logout")) {
    4342                                if (user != null) {
    … …  
    4847                                        resp.Redirect ("/static/index.html");
    4948                                        return;
    50                                 } else {
    51                                         result.Append ("<h1>Not logged in, <a href=\"/static/index.html\">click to return to main page</a>.</h1>");
    5249                                }
     50
     51                                result.Append (
     52                                        "<h1>Not logged in, <a href=\"/static/index.html\">click to return to main page</a>.</h1>");
    5353                        } else if (subpath.StartsWith ("login")) {
    5454                                string host = (Web.isSslRedirected (req) ? "https://" : "http://") + req.UserHostName;
    … …  
    5757                                return;
    5858                        } else {
    59                                 result.Append ("<h1>Unknown command, <a href=\"/static/index.html\">click to return to main page</a>.</h1>");
     59                                result.Append (
     60                                        "<h1>Unknown command, <a href=\"/static/index.html\">click to return to main page</a>.</h1>");
    6061                        }
    6162
    … …  
    6869                        resp.OutputStream.Write (buf, 0, buf.Length);
    6970                }
    70 
    7171        }
    72 
    7372}
    74 

  • binary-improvements/MapRendering/Web/Handlers/SimpleRedirectHandler.cs

    r244 r325  
    1 using System;
    21using System.Net;
    32
    4 namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    5 {
    6         public class SimpleRedirectHandler : PathHandler
    7         {
    8                 string target;
     3namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
     4        public class SimpleRedirectHandler : PathHandler {
     5                private readonly string target;
    96
    10                 public SimpleRedirectHandler (string target, string moduleName = null) : base(moduleName)
    11                 {
     7                public SimpleRedirectHandler (string target, string moduleName = null) : base (moduleName) {
    128                        this.target = target;
    139                }
    1410
    15                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel)
    16                 {
     11                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
     12                        int permissionLevel) {
    1713                        resp.Redirect (target);
    1814                }
    1915        }
    2016}
    21 

  • binary-improvements/MapRendering/Web/Handlers/StaticHandler.cs

    r251 r325  
    1 using System;
    2 using System.Collections.Generic;
    31using System.IO;
    42using System.Net;
    5 using System.Threading;
     3using AllocsFixes.FileCache;
    64
    7 namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    8 {
    9         public class StaticHandler : PathHandler
    10         {
    11                 private string datapath;
    12                 private string staticPart;
    13                 private AllocsFixes.FileCache.AbstractCache cache;
    14                 private bool logMissingFiles;
     5namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
     6        public class StaticHandler : PathHandler {
     7                private readonly AbstractCache cache;
     8                private readonly string datapath;
     9                private readonly bool logMissingFiles;
     10                private readonly string staticPart;
    1511
    16                 public StaticHandler (string staticPart, string filePath, AllocsFixes.FileCache.AbstractCache cache, bool logMissingFiles, string moduleName = null) : base(moduleName)
    17                 {
     12                public StaticHandler (string staticPart, string filePath, AbstractCache cache, bool logMissingFiles,
     13                        string moduleName = null) : base (moduleName) {
    1814                        this.staticPart = staticPart;
    19                         this.datapath = filePath;
     15                        datapath = filePath;
    2016                        this.cache = cache;
    2117                        this.logMissingFiles = logMissingFiles;
    2218                }
    2319
    24                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel)
    25                 {
     20                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
     21                        int permissionLevel) {
    2622                        string fn = req.Url.AbsolutePath.Remove (0, staticPart.Length);
    2723
    … …  
    3329                                resp.OutputStream.Write (content, 0, content.Length);
    3430                        } else {
    35                                 resp.StatusCode = (int)HttpStatusCode.NotFound;
    36                                 if (logMissingFiles)
    37                                         Log.Out ("Web:Static:FileNotFound: \"" + req.Url.AbsolutePath + "\" @ \"" + datapath + "/" + req.Url.AbsolutePath.Remove (0, staticPart.Length) + "\"");
    38                                 return;
     31                                resp.StatusCode = (int) HttpStatusCode.NotFound;
     32                                if (logMissingFiles) {
     33                                        Log.Out ("Web:Static:FileNotFound: \"" + req.Url.AbsolutePath + "\" @ \"" + datapath + "/" +
     34                                                 req.Url.AbsolutePath.Remove (0, staticPart.Length) + "\"");
     35                                }
    3936                        }
    4037                }
    4138        }
    4239}
    43 

  • binary-improvements/MapRendering/Web/Handlers/UserStatusHandler.cs

    r309 r325  
    1 using System;
    2 using System.Collections.Generic;
    3 using System.IO;
    41using System.Net;
    5 using System.Threading;
    6 using System.Text;
    72using AllocsFixes.JSON;
     3using AllocsFixes.NetConnections.Servers.Web.API;
    84
    9 namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    10 {
     5namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    116        public class UserStatusHandler : PathHandler {
    12                 public UserStatusHandler (string moduleName = null) : base(moduleName) {
     7                public UserStatusHandler (string moduleName = null) : base (moduleName) {
    138                }
    149
    15                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel) {
     10                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
     11                        int permissionLevel) {
    1612                        JSONObject result = new JSONObject ();
    1713
    … …  
    2319                                JSONObject permObj = new JSONObject ();
    2420                                permObj.Add ("module", new JSONString (perm.module));
    25                                 permObj.Add ("allowed", new JSONBoolean (WebPermissions.Instance.ModuleAllowedWithLevel (perm.module, permissionLevel)));
     21                                permObj.Add ("allowed",
     22                                        new JSONBoolean (WebPermissions.Instance.ModuleAllowedWithLevel (perm.module, permissionLevel)));
    2623                                perms.Add (permObj);
    2724                        }
     25
    2826                        result.Add ("permissions", perms);
    2927
    30                         AllocsFixes.NetConnections.Servers.Web.API.WebAPI.WriteJSON (resp, result);
     28                        WebAPI.WriteJSON (resp, result);
    3129                }
    32 
    3330        }
    34 
    3531}
    36 
Note: See TracChangeset for help on using the changeset viewer.