MOVEMENT

Controllers/NameServerController.cs

@@ -0,0 +1,59 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using System.Runtime.CompilerServices;
+using System.Text.Json.Serialization;
+
+namespace ir23.Controllers
+{
+    [Route("/")]
+    [ApiController]
+    public class NameServerController : ControllerBase
+    {
+
+        public string serverUrl = "https://localhost:443";
+
+        [HttpGet]
+        public IActionResult NameServer()
+        {
+            return Ok(new
+            {
+                Accounts = serverUrl,
+                AI = serverUrl,
+                API = serverUrl,
+                Auth = serverUrl,
+                BugReporting = serverUrl,
+                Cards = serverUrl,
+                CDN = serverUrl+"/cdnserver",
+                Chat = serverUrl,
+                Clubs = serverUrl,
+                CMS = serverUrl,
+                Commerce = serverUrl,
+                Data = serverUrl,
+                DataCollection = serverUrl,
+                Discovery = serverUrl,
+                Econ = serverUrl,
+                GameLogs = serverUrl,
+                Geo = serverUrl,
+                Images = serverUrl+"/imageserver",
+                Leaderboard = serverUrl,
+                Link = serverUrl,
+                Lists = serverUrl,
+                Matchmaking = serverUrl,
+                Moderation = serverUrl,
+                Notifications = serverUrl,
+                PlatformNotifications = serverUrl,
+                PlayerSettings = serverUrl,
+                RoomComments = serverUrl,
+                Rooms = serverUrl,
+                Storage = serverUrl,
+                Strings = serverUrl,
+                StringsCDN = serverUrl+"/stringcdnserver",
+                Studio = serverUrl,
+                Thorn = serverUrl+"/thornserver",
+                Videos = serverUrl+"/cdnserver",
+                WWW = serverUrl
+
+            });
+        }
+    }
+}

Controllers/PlayerReportingController.cs

@@ -0,0 +1,22 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class PlayerReportingController : ControllerBase
+    {
+        [HttpGet("v1/moderationBlockDetails")]
+        public IActionResult modblockdetails()
+        {
+            return Ok(new
+            {
+                ReportCategory = 0,
+                Duration = 0,
+                GameSessionId = 0,
+                Message = ""
+            });
+        }
+    }
+}

Controllers/accountController.cs

@@ -0,0 +1,49 @@
+using ir23.Data;
+using ir23.VerificationModels;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace ir23.Controllers
+{
+    [Route("[controller]")]
+    [ApiController]
+    public class accountController : ControllerBase
+    {
+        private readonly AppDbContext _db;
+        private readonly JwtService _jwtService;
+
+        public accountController(AppDbContext db, JwtService jwtService)
+        {
+            _db = db;
+            _jwtService = jwtService;
+        }
+
+
+        [HttpGet("bulk")]
+        public async Task<IActionResult> getbulkuserdata(
+            [FromQuery] List<long> id
+            )
+        {
+            var accountDatas = await _db.Accounts.Where(
+                p => id.Contains(p.Id)
+                ).ToListAsync();
+
+            return Ok(accountDatas);
+        }
+
+        [HttpGet("me")]
+        public async Task<IActionResult> getmyaccountdetails(
+            [FromHeader] string Authorization
+            )
+        {
+
+            var playerId = _jwtService.VerifyToken(Authorization);
+
+            var account = await _db.Accounts
+                .FirstOrDefaultAsync(p => p.Id == playerId);
+
+            return Ok(account);
+        }
+    }
+}

Controllers/avatarController.cs

@@ -0,0 +1,75 @@
+using ir23.Data;
+using ir23.VerificationModels;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class avatarController : ControllerBase
+    {
+
+        private readonly JwtService _jwtService;
+        private readonly AppDbContext _db;
+
+        public avatarController(JwtService jwtService, AppDbContext db)
+        {
+            _jwtService = jwtService;
+            _db = db;
+        }
+
+
+
+        [HttpGet("v1/defaultunlocked")]
+        public IActionResult defaultunlocked()
+        {
+            return Ok(new List<object>());
+        }
+
+        [HttpGet("v2")]
+        public async Task<IActionResult> GetAvatar(
+            [FromHeader] string Authorization
+            )
+        {
+            var playerId = _jwtService.VerifyToken(Authorization);
+
+
+            if (playerId == null) return Unauthorized();
+
+            var avatardata = await _db.Avatars
+                .FirstOrDefaultAsync(x => x.accountId == playerId);
+
+            if (avatardata == null)
+            {
+                avatardata = new avatar
+                {
+                    accountId = playerId,
+                    OutfitSelections = "",
+                    FaceFeatures = "",
+                    SkinColour = "",
+                    HairColor = ""
+                };
+
+                _db.Avatars.Add(avatardata);
+                await _db.SaveChangesAsync();
+            }
+
+            return Ok(avatardata);
+        }
+
+        [HttpGet("v4/items")]
+        public IActionResult getMyUnlockedItems()
+        {
+            return Ok(new List<object>());
+        }
+
+        [HttpGet("v1/defaultbaseavataritems")]
+        public IActionResult iofiowegjnioio()
+        {
+            return Ok(new List<object>());
+        }
+    }
+}

Controllers/cachedloginController.cs

@@ -0,0 +1,56 @@
+using ir23.Data;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using System.Threading.Tasks;
+
+namespace ir23.Controllers
+{
+    [Route("[controller]")]
+    [ApiController]
+    public class cachedloginController : ControllerBase
+    {
+        private readonly AppDbContext _db;
+
+        public cachedloginController(AppDbContext db)
+        {
+            _db = db;
+        }
+
+
+        [HttpGet("forplatformid/{platform}/{platformid}")]
+        public async Task<IActionResult> findcachedaccounts(
+            [FromRoute] int platform,
+            [FromRoute] string platformid
+            )
+        {
+
+            var accountIds = await _db.PlatformDatas
+                .Where(p => p.platform == platform && p.platformId == platformid)
+                
+                .ToListAsync();
+
+            //.Select(p => p.accountId)
+
+
+            /*var accounts = await _db.Accounts
+                .Where(p => accountIds.Contains(p.Id))
+                .ToListAsync();
+            */
+
+            return Ok(accountIds);
+        }
+
+        [HttpPost("forplatformids")]
+        public async Task<IActionResult> efiojwo()
+        {
+            using (var reader = new StreamReader(Request.Body))
+            {
+                var body = await reader.ReadToEndAsync();
+                Console.WriteLine(body);
+            }
+
+            return Ok(new List<object>());
+        }
+    }
+}

Controllers/checklistController.cs

@@ -0,0 +1,16 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class checklistController : ControllerBase
+    {
+        [HttpGet("v1/current")]
+        public IActionResult ji0owefowjiefwefjoi()
+        {
+            return Ok(new List<object>());
+        }
+    }
+}

Controllers/configController.cs

@@ -0,0 +1,24 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class configController : ControllerBase
+    {
+        [HttpGet("v1/amplitude")]
+        public IActionResult amplitudepls()
+        {
+            return Ok(new
+            {
+                AmplitudeKey = "6d44c7130493d0b7b217ca1281110d77",
+                UseRudderStack = false,
+                RudderStackKey = "",
+                UseStatSig = true,
+                StatSigKey = "client-55AOkoM7cfxsYT3yu5yoA01fo9Jipq9HQ1Y0IB6XHlj",
+                StatSigEnvironment = 0
+            });
+        }
+    }
+}

Controllers/connectController.cs

@@ -0,0 +1,126 @@
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using System.Text.Json;
+using System.Net.Http;
+using ir23.VerificationModels;
+using Microsoft.AspNetCore.Http.Metadata;
+
+namespace ir23.Controllers
+{
+    [Route("[controller]")]
+    [ApiController]
+    public class connectController : ControllerBase
+    {
+
+        private readonly SteamAuth _steamAuth;
+        private readonly JwtService _jwtService;
+
+        public connectController(SteamAuth steamAuth, JwtService jwtService)
+        {
+            _steamAuth = steamAuth;
+            _jwtService = jwtService;
+        }
+
+
+        [HttpPost("token")]
+        public async Task<IActionResult> connecttoken([FromForm] LoginRequest request)
+        {
+            if (request.grant_type == "refresh_token")
+            {
+                var refreshToken = Request.Form["refresh_token"].ToString();
+
+                refreshToken = System.Text.RegularExpressions.Regex.Unescape(refreshToken);
+                refreshToken = refreshToken.Trim();
+
+                Console.WriteLine(refreshToken);
+
+                var accountId = await _jwtService.ValidateRefreshToken(refreshToken);
+
+                Console.WriteLine(accountId);
+
+                if (accountId == null)
+                    return Unauthorized();
+
+                var accessToken = _jwtService.GenerateToken(accountId.Value);
+                var newRefreshToken = await _jwtService.GenerateRefreshToken(accountId.Value);
+
+                return Ok(new
+                {
+                    access_token = accessToken,
+                    refresh_token = newRefreshToken,
+                    error = "",
+                    error_description = "",
+                    key = ""
+                });
+            }
+
+            var j = JsonSerializer.Deserialize<PlatformAuth>(request.platform_auth);
+
+            if (j == null || string.IsNullOrEmpty(j.Ticket) || string.IsNullOrEmpty(j.AppId))
+                return BadRequest();
+
+            var steamResult = await _steamAuth.VerifySteamTicket(
+                j.Ticket,
+                j.AppId,
+                request.account_id
+            );
+
+            if (steamResult)
+            {
+                var accessToken = _jwtService.GenerateToken(request.account_id);
+                var refreshToken = await _jwtService.GenerateRefreshToken(request.account_id);
+
+                return Ok(new
+                {
+                    access_token = accessToken,
+                    refresh_token = refreshToken,
+                    error = "",
+                    error_description = "",
+                    key = ""
+                });
+            }
+
+            return Unauthorized();
+        }
+
+
+
+
+
+
+
+
+
+
+
+        public class LoginRequest
+        {
+            public string grant_type { get; set; }
+            public long account_id { get; set; }
+            public string client_id { get; set; }
+            public string client_secret { get; set; }
+            public string platform { get; set; }
+            public string platform_id { get; set; }
+            public string device_id { get; set; }
+            public string device_class { get; set; }
+            public string time { get; set; }
+            public string ver { get; set; }
+            public string cid { get; set; }
+            public string build_key { get; set; }
+            public string asid { get; set; }
+            public string locale { get; set; }
+            public string isInitialLogin { get; set; }
+            public string dinfo { get; set; }
+            public string eac_challenge { get; set; }
+            public string eac_response { get; set; }
+            public string platform_auth { get; set; }
+        }
+
+        public class PlatformAuth
+        {
+            public string Ticket { get; set; }
+            public string AppId { get; set; }
+        }
+    }
+}

Controllers/customAvatarItemsController.cs

@@ -0,0 +1,30 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json;
+using System.Text.Json.Serialization;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class customAvatarItemsController : ControllerBase
+    {
+        [HttpGet("v1/isCreationAllowedForAccount")]
+        public IActionResult idefk()
+        {
+            return Ok(new iscreationallowedforaccountresponse
+            {
+                success = true,
+                value = null
+            });
+        }
+
+
+
+        public class iscreationallowedforaccountresponse
+        {
+            [JsonPropertyName("success")] public bool success { get; set; }
+            [JsonPropertyName("value")] public string value { get; set; }
+        }
+    }
+}

Controllers/dataController.cs

@@ -0,0 +1,16 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("[controller]")]
+    [ApiController]
+    public class dataController : ControllerBase
+    {
+        [HttpPost("event")]
+        public IActionResult eventttetetijeit()
+        {
+            return Ok(new List<object>());
+        }
+    }
+}

Controllers/eacController.cs

@@ -0,0 +1,22 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("[controller]")]
+    [ApiController]
+    public class eacController : ControllerBase
+    {
+        [HttpGet("challenge")]
+        public IActionResult challengeEAC()
+        {
+            return Ok("\"AQAAAGd9O3h2ynQW6Y/1MhdZC8VoHygxyTzmiRvAfpiRtJEBQ+NVaXMStRTsYQk42H1hbB7NGKhIpgfShk+ADtRW9EU/YF5320eGmINJZAqkm3pyX9QF/w1QT4IB2EQfOqTfpryQ3QFchXYqDgg/SbX+/X9mgzssbflIw3OAK+c=\"");
+        }
+
+        [HttpGet("challenge/patch")]
+        public IActionResult challengeEACPATCH()
+        {
+            return Ok("\"AQAAAHsg7mW5FQEE9HVl9EKMWXrqDzQxUCdgV/IPuQfbRgTx+cGnQqhhAgv1RvpihEC77gQ29JdoGFn2806Q+QPEj7nYg9C8pynbaiSVO8rKLJPvROsHuSXVJpQMv3TD8KyK3Y+n5bb86vAb5kRdZGD//uC8HY+D9jJLlEfTUlU=\"");
+        }
+    }
+}

Controllers/econController.cs

@@ -0,0 +1,20 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("[controller]")]
+    [ApiController]
+    public class econController : ControllerBase
+    {
+        [HttpGet("customAvatarItems/v1/owned")]
+        public IActionResult ownedavataritemscustom()
+        {
+            return Ok(new
+            {
+                Results = new List<object>(),
+                TotalResults = 0
+            });
+        }
+    }
+}

Controllers/gameconfigsController.cs

@@ -0,0 +1,16 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class gameconfigsController : ControllerBase
+    {
+        [HttpGet("v1/all")]
+        public IActionResult allconfig()
+        {
+            return Ok(new List<object>());
+        }
+    }
+}

Controllers/gamesightController.cs

@@ -0,0 +1,16 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class gamesightController : ControllerBase
+    {
+        [HttpPost("event")]
+        public IActionResult evennetentio()
+        {
+            return Ok(new List<object>());
+        }
+    }
+}

Controllers/imageserverController.cs

@@ -0,0 +1,26 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using System.Security.AccessControl;
+
+namespace ir23.Controllers
+{
+    [Route("[controller]")]
+    [ApiController]
+    public class imageserverController : ControllerBase
+    {
+        /*[HttpGet("{imagename}")]
+        public async Task<IActionResult> GetImage([FromRoute] string imagename, [FromQuery] string? sig = null)
+        {
+            var path = Path.Combine(Directory.GetCurrentDirectory(), "cdn", "images", imagename);
+
+            if (sig == "p1")
+            {
+                Response.Headers.Add("content-signature", "key-id=KEY:RSA:p1.rec.net; data=DE2ycF0i4LLjAnqUGvP6lqAPe3HGKLjmZ6nK8m3XidVFLabwQrYIb1WczC5Y6gN9MeDka0ux82yh29GrmSKEq85GSexTFlirnfoPGALl7fB5zeMfaQrwD0dbmO2vMnKe+ViP2RRCaotdYPYXWtEikpJUCVsH+o06EsBYOA3Nnxd93GQPnq0lo9Befjlxvhb9Q0gYBc45rPx0nkAYL2JixwDEroLgsQ8b69bnGE/gIAF0QkGwwDx2E4gMYJdL7xzWnpaIEsHjutFiot2cgHFYRIi0dJ4Ln7ExPgApQKa0Q4haU/qGvCBlhwtmbmnEFvlcX3bVlTcMGfcg6AKRKlRRpA==");
+            }
+            
+            byte[] imagebytes = await System.IO.File.ReadAllBytesAsync(path);
+
+            return File(imagebytes, "image/png");
+        }*/
+    }
+}

Controllers/objectivesController.cs

@@ -0,0 +1,20 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class objectivesController : ControllerBase
+    {
+        [HttpGet("v1/myprogress")]
+        public IActionResult GetMyProgress()
+        {
+            return Ok(new
+            {
+                Objectives = new List<object>(),
+                ObjectiveGroups = new List<object>()
+            });
+        }
+    }
+}

Controllers/playerController.cs

@@ -0,0 +1,16 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("[controller]")]
+    [ApiController]
+    public class playerController : ControllerBase
+    {
+        [HttpPost("login")]
+        public IActionResult LoginUser()
+        {
+            return Ok(new List<object>());
+        }
+    }
+}

Controllers/playerReputationController.cs

@@ -0,0 +1,64 @@
+using ir23.Data;
+using ir23.VerificationModels;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using System.Threading.Tasks;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class playerReputationController : ControllerBase
+    {
+        private readonly AppDbContext _db;
+        private readonly JwtService _jwtService;
+
+        public playerReputationController(AppDbContext db, JwtService jwtService)
+        {
+            _db = db;
+            _jwtService = jwtService;
+        }
+
+
+        [HttpGet("v2/bulk")]
+        public async Task<IActionResult> GetBulkRep([FromQuery] List<int> id)
+        {
+            var playerreputations = new List<reputation>();
+
+            foreach (int i in id)
+            {
+
+                var rep = await _db.Reputations
+                    .FirstOrDefaultAsync(x => x.accountId == i);
+
+                if (rep == null)
+                {
+                    rep = new reputation
+                    {
+                        accountId = i,
+                        IsCheerful = false,
+                        Noteriety = 0,
+                        CheerGeneral = 0,
+                        CheerHelpful = 0,
+                        CheerGreatHost = 0,
+                        CheerSportsman = 0,
+                        CheerCreative = 0,
+                        CheerCredit = 20,
+                        SubscriberCount = 0,
+                        SubscribedCount = 0,
+                        SelectedCheer = 0
+                    };
+
+                    _db.Reputations.Add(rep);
+                    await _db.SaveChangesAsync();
+                }
+
+                playerreputations.Add(rep);
+
+            }
+
+            return Ok(playerreputations);
+        }
+    }
+}

Controllers/playersController.cs

@@ -0,0 +1,57 @@
+using ir23.Data;
+using ir23.VerificationModels;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class playersController : ControllerBase
+    {
+        private readonly AppDbContext _db;
+        private readonly JwtService _jwtService;
+
+        public playersController(AppDbContext db, JwtService jwtService)
+        {
+            _db = db;
+            _jwtService = jwtService;
+        }
+
+
+
+        [HttpGet("v2/progression/bulk")]
+        public async Task<IActionResult> progressionbulk([FromQuery] List<int> id)
+        {
+            var finalprog = new List<progression>();
+
+            foreach (int i in id)
+            {
+
+
+                var _progression = await _db.Progressions
+                    .FirstOrDefaultAsync(x => x.PlayerId == i);
+
+                if (_progression == null)
+                {
+                    _progression = new progression
+                    {
+                        PlayerId = i,
+                        Level = 1,
+                        XP = 0
+                    };
+
+                    _db.Progressions.Add(_progression);
+                    await _db.SaveChangesAsync();
+
+
+                }
+
+                finalprog.Add(_progression);
+            }
+
+            return Ok(finalprog);
+        }
+    }
+}

Controllers/playersettingsController.cs

@@ -0,0 +1,42 @@
+using ir23.Data;
+using ir23.VerificationModels;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using System.Threading.Tasks;
+
+namespace ir23.Controllers
+{
+    [Route("[controller]")]
+    [ApiController]
+    public class playersettingsController : ControllerBase
+    {
+        private readonly AppDbContext _db;
+        private readonly JwtService _jwtService;
+
+        public playersettingsController(AppDbContext db, JwtService jwtService)
+        {
+            _db = db;
+            _jwtService = jwtService;
+        }
+
+
+
+        [HttpGet]
+        public async Task<IActionResult> GetSettings(
+            [FromHeader] string Authorization
+            )
+        {
+
+            var playerId = _jwtService.VerifyToken(Authorization);
+
+            if (playerId == null) return Unauthorized();
+
+            var playersettings = await _db.PlayerSettings
+                .Where(x => x.accountId == playerId)
+                .ToListAsync();
+
+            return Ok(playersettings);
+        }
+    }
+}

Controllers/relationshipsController.cs

@@ -0,0 +1,16 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class relationshipsController : ControllerBase
+    {
+        [HttpGet("v2/get")]
+        public IActionResult getRelationships()
+        {
+            return Ok(new List<object>());
+        }
+    }
+}

Controllers/threadController.cs

@@ -0,0 +1,16 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ir23.Controllers
+{
+    [Route("[controller]")]
+    [ApiController]
+    public class threadController : ControllerBase
+    {
+        [HttpGet]
+        public IActionResult getThreads()
+        {
+            return Ok(new List<object>());
+        }
+    }
+}

Controllers/versioncheckController.cs

@@ -0,0 +1,30 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Primitives;
+
+namespace ir23.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class versioncheckController : ControllerBase
+    {
+        [HttpGet("v4")]
+        public IActionResult checkversion([FromQuery] string v)
+        {
+            if (v == "20230331")
+            {
+                return Ok(new
+                {
+                    VersionStatus = 0
+                });
+            }
+            else
+            {
+                return Ok(new
+                {
+                    VersionStatus = 1
+                });
+            }
+        }
+    }
+}