Esempio n. 1
0
        public async Task <object> UpdateAsync(
            [FromBody] WriteNewsItemRequest body)
        {
            var newsItem = await _newsItemRepository.GetAsync(body.Id);

            if (newsItem == null)
            {
                return(NotFound(JResponse.Error("News item not found.")));
            }

            newsItem.Modified = DateTime.UtcNow;
            if (body.Title != null)
            {
                newsItem.Title = body.Title;
            }
            if (body.Html != null)
            {
                newsItem.Html = body.Html;
            }
            if (body.Published == true)
            {
                newsItem.Published = DateTime.UtcNow;
            }
            _logger.LogInformation($"Updating news item: {newsItem.Title} (updated by {User.Identity.Name}");
            await _newsItemRepository.UpdateAsync(newsItem);

            return(JResponse.OK());
        }
Esempio n. 2
0
        public async Task <object> GetServersAsync(
            [FromServices] HttpClient httpClient,
            [FromServices] IServerRepository serverRepository)
        {
            var accept  = HttpContext.Request.Headers[HeaderNames.Accept];
            var accepts = accept
                          .SelectMany(x => x.Split(',', StringSplitOptions.RemoveEmptyEntries))
                          .ToArray();
            var returnJson =
                accepts.Contains(MimeTypes.ApplicationJson, StringComparer.InvariantCultureIgnoreCase) ||
                accepts.Contains(MimeTypes.TextJson, StringComparer.InvariantCultureIgnoreCase);

            try
            {
                // A good time to clean up any expired servers
                await DoServerCleanupAsync(serverRepository);

#if DEBUG
                var servers = await GetServersFromLiveSiteAsync(httpClient);
#else
                var servers = await serverRepository.GetAllAsync();
#endif
                if (returnJson)
                {
                    var response = new JGetServersResponse()
                    {
                        status  = JStatus.OK,
                        Servers = servers
                    };
                    return(ConvertResponse(response));
                }
                else
                {
                    servers = servers
                              .OrderByDescending(x => x.Players)
                              .ThenBy(x => x.RequiresPassword)
                              .ThenByNaturalDescending(x => x.Version)
                              .ThenBy(x => x.Name)
                              .ToArray();
                    return(View("Views/Servers.cshtml", servers));
                }
            }
            catch
            {
                var msg = "Unable to connect to fetch servers.";
                if (returnJson)
                {
                    return(ConvertResponse(JResponse.Error(msg)));
                }
                else
                {
                    return(StatusCode(StatusCodes.Status500InternalServerError, msg));
                }
            }
        }
        protected override async Task <bool> HandleUnauthorizedAsync(ChallengeContext context)
        {
            HttpResponse httpResponse = Context.Response;

            httpResponse.Headers[HeaderNames.ContentType] = MimeTypes.ApplicationJson;

            string response = JsonConvert.SerializeObject(JResponse.Error(JErrorMessages.InvalidToken));
            await httpResponse.WriteAsync(response);

            return(false);
        }
Esempio n. 4
0
 public async Task <object> VerifyAsync(
     [FromServices] UserAccountService userAccountService,
     [FromQuery] string token)
 {
     if (await userAccountService.VerifyAccountAsync(token))
     {
         return(JResponse.OK());
     }
     else
     {
         return(BadRequest(JResponse.Error("Invalid token")));
     }
 }
Esempio n. 5
0
        public async Task <object> DeleteAsync(
            [FromBody] WriteNewsItemRequest body)
        {
            if (body.Id == null)
            {
                return(BadRequest(JResponse.Error("News item id not specified.")));
            }

            _logger.LogInformation($"Deleting news item: {body.Id} (deleted by {User.Identity.Name}");
            await _newsItemRepository.DeleteAsync(body.Id);

            return(JResponse.OK());
        }
Esempio n. 6
0
        public async Task <IJResponse> Login(
            [FromServices] OpenRCT2org.IUserApi userApi,
            [FromServices] IUserSessionRepository userSessionRepository,
            [FromServices] DB.Abstractions.IUserRepository userRepository,
            [FromBody] JLoginRequest body)
        {
            try
            {
                Guard.ArgumentNotNull(body);
                Guard.ArgumentNotNull(body.user);
                Guard.ArgumentNotNull(body.password);
            }
            catch
            {
                return(JResponse.Error(JErrorMessages.InvalidRequest));
            }

            _logger.LogInformation("User login: {0}", body.user);

            OpenRCT2org.JUser orgUser;
            try
            {
                orgUser = await userApi.AuthenticateUser(body.user, body.password);
            }
            catch (OpenRCT2org.OpenRCT2orgException)
            {
                return(JResponse.Error(ErrorAuthenticationFailed));
            }

            var ourUser = await userRepository.GetUserFromOpenRCT2orgIdAsync(orgUser.userId);

            if (ourUser == null)
            {
                ourUser = new DB.Models.User()
                {
                    OpenRCT2orgId = orgUser.userId,
                    UserName      = orgUser.name
                };
                await userRepository.InsertUserAsync(ourUser);
            }

            string token = await userSessionRepository.CreateToken(orgUser.userId);

            return(new JLoginResponse()
            {
                status = JStatus.OK,
                user = orgUser.name,
                token = token
            });
        }
Esempio n. 7
0
 public override void OnActionExecuting(ActionExecutingContext filterContext)
 {
     if (filterContext.Controller is Controller controller)
     {
         var modelState = controller.ModelState;
         if (modelState?.IsValid == false)
         {
             var firstError = new SerializableError(modelState).FirstOrDefault();
             var message    = "Invalid request";
             if (firstError.Value is string[] messages && messages.Length != 0)
             {
                 message = messages[0];
             }
             filterContext.Result = controller.BadRequest(JResponse.Error(message));
         }
     }
     base.OnActionExecuting(filterContext);
 }
Esempio n. 8
0
        public async Task <IJResponse> AdvertiseHeartbeat(
            [FromServices] IServerRepository serverRepository,
            [FromBody] JAdvertiseHeartbeatRequest body)
        {
            Server server = await serverRepository.GetByToken(body.token);

            if (server == null)
            {
                return(JResponse.Error("Server not registered."));
            }

            server.Players       = body.players;
            server.GameInfo      = body.gameInfo;
            server.LastHeartbeat = DateTime.Now;
            await serverRepository.AddOrUpdate(server);

            return(ConvertResponse(JResponse.OK()));
        }
Esempio n. 9
0
        public async Task <object> SignInAsync(
            [FromServices] UserAuthenticationService userAuthenticationService,
            [FromBody] SignInRequest body)
        {
            var(user, authToken) = await userAuthenticationService.AuthenticateAsync(body.Username, body.Password);

            if (authToken == null)
            {
                var result = JResponse.Error("Invalid username or password.");
                return(StatusCode(StatusCodes.Status401Unauthorized, result));
            }

            return(new
            {
                status = JStatus.OK,
                token = authToken.Token,
                user = GetProfileInfo(user)
            });
        }
Esempio n. 10
0
        public async Task <object> PutAsync(
            [FromRoute] string name,
            [FromBody] UpdateUserRequest body)
        {
            var user = await _userRepository.GetUserFromNameAsync(name.ToLower());

            if (user == null)
            {
                return(NotFound(JResponse.Error("User not found")));
            }

            _logger.LogInformation($"Updating user: {user.Name}");

            if (body.Bio != null)
            {
                user.Bio = body.Bio;
            }
            await _userRepository.UpdateUserAsync(user);

            return(JResponse.OK());
        }
Esempio n. 11
0
        public async Task <object> GetAsync(string name)
        {
            var user = await _userRepository.GetUserFromNameAsync(name.ToLower());

            if (user == null)
            {
                return(NotFound(JResponse.Error("User not found")));
            }
            return(new
            {
                Status = JStatus.OK,
                Result = new
                {
                    user.Name,
                    user.Bio,
                    Joined = user.Created.ToString("d MMMM yyyy"),
                    Comments = 0,
                    Uploads = 0,
                    Traits = new [] { "Developer", "Streamer" },
                    Avatar = GetAvatarUrl(user)
                }
            });
        }
Esempio n. 12
0
        public async Task <object> CreateAsync(
            [FromServices] GoogleRecaptchaService recaptchaService,
            [FromServices] UserAccountService userAccountService,
            [FromBody] CreateUserRequest body)
        {
            var remoteIp = HttpContext.Connection.RemoteIpAddress.ToString();

            if (!await recaptchaService.ValidateAsync(remoteIp, body.Captcha).ConfigureAwait(false))
            {
                return(BadRequest(JResponse.Error("reCAPTCHA validation failed.")));
            }
            if (!await userAccountService.IsNameAvailabilityAsync(body.Username))
            {
                return(BadRequest(JResponse.Error("User name already taken.")));
            }
            if (!await userAccountService.IsEmailAvailabilityAsync(body.Email))
            {
                return(BadRequest(JResponse.Error("Email address already registered.")));
            }
            await userAccountService.CreateAccountAsync(body.Username, body.Email, body.Password);

            return(JResponse.OK());
        }
Esempio n. 13
0
        public async Task <IJResponse> AdvertiseHeartbeatAsync(
            [FromServices] IServerRepository serverRepository,
            [FromBody] JAdvertiseHeartbeatRequest body)
        {
            if (string.IsNullOrEmpty(body?.Token))
            {
                return(ConvertResponse(JResponse.Error(JErrorMessages.InvalidToken)));
            }

            Server server = await serverRepository.GetByTokenAsync(body.Token);

            if (server == null)
            {
                return(ConvertResponse(JResponse.Error(JErrorMessages.ServerNotRegistered)));
            }

            server.Players       = body.Players;
            server.GameInfo      = body.GameInfo;
            server.LastHeartbeat = DateTime.Now;
            await serverRepository.AddOrUpdateAsync(server);

            return(ConvertResponse(JResponse.OK()));
        }
Esempio n. 14
0
        public async Task <IJResponse> Logout(
            [FromServices] IUserSessionRepository userSessionRepository,
            [FromBody] JLogoutRequest body)
        {
            try
            {
                Guard.ArgumentNotNull(body);
                Guard.ArgumentNotNull(body.token);
            }
            catch
            {
                return(JResponse.Error(JErrorMessages.InvalidRequest));
            }

            if (await userSessionRepository.RevokeToken(body.token))
            {
                return(JResponse.OK());
            }
            else
            {
                return(JResponse.Error(JErrorMessages.InvalidToken));
            }
        }
Esempio n. 15
0
        public async Task <object> GetServers(
            [FromServices] IServerRepository serverRepository)
        {
            try
            {
                Server[] servers = await serverRepository.GetAll();

                JServer[] jServers = servers.Select(x => JServer.FromServer(x))
                                     .ToArray();

                await DoServerCleanup(serverRepository);

                var response = new JGetServersResponse()
                {
                    status  = JStatus.OK,
                    servers = jServers
                };
                return(ConvertResponse(response));
            }
            catch
            {
                return(ConvertResponse(JResponse.Error("Unable to connect to fetch servers.")));
            }
        }
Esempio n. 16
0
        public async Task <IJResponse> AdvertiseServerAsync(
            [FromServices] IServerRepository serverRepository,
            [FromServices] Random random,
            [FromBody] JAdvertiseServerRequest body)
        {
            var remoteAddress = GetRemoteAddress();

            if (String.IsNullOrEmpty(remoteAddress))
            {
                return(JResponse.Error(JErrorMessages.ServerError));
            }

            Server serverInfo;

            try
            {
                string serverInfoJson;
                using (var client = new OpenRCT2Client())
                {
                    _logger.LogInformation("Connecting to {0}:{1}", remoteAddress, body.Port);
                    await client.Connect(remoteAddress, body.Port);

                    _logger.LogInformation("Requesting server info from {0}:{1}", remoteAddress, body.Port);
                    serverInfoJson = await client.RequestServerInfo();
                }
                serverInfo = JsonConvert.DeserializeObject <Server>(serverInfoJson);
            }
            catch (SocketException)
            {
                return(ConvertResponse(JResponse.Error("Unable to connect to server, make sure your ports are open.")));
            }
            catch (TimeoutException)
            {
                return(ConvertResponse(JResponse.Error("Timed out while waiting for server response.")));
            }
            catch
            {
                return(ConvertResponse(JResponse.Error("Unable to advertise server.")));
            }

            var token = random.NextBytes(8)
                        .ToHexString();
            var server = new Server()
            {
                Token         = token,
                LastHeartbeat = DateTime.Now,

                Addresses = new ServerAddressList()
                {
                    IPv4 = new string[] { remoteAddress },
                    IPv6 = new string[0]
                },
                Port             = body.Port,
                Name             = serverInfo.Name,
                Description      = serverInfo.Description,
                Provider         = serverInfo.Provider,
                RequiresPassword = serverInfo.RequiresPassword,
                Players          = serverInfo.Players,
                MaxPlayers       = serverInfo.MaxPlayers,
                Version          = serverInfo.Version
            };

            _logger.LogInformation("Registering server {0} [{1}:{2}]", serverInfo.Name, remoteAddress, body.Port);
            await serverRepository.AddOrUpdateAsync(server);

            var response = new JAdvertiseServerResponse()
            {
                status = JStatus.OK,
                Token  = token
            };

            return(ConvertResponse(response));
        }