added endpoints for moving application instances

Player.Api/Controllers/ApplicationController.cs

@@ -252,7 +252,7 @@ public async Task<IActionResult> DeleteApplication(Guid id, CancellationToken ct
         [SwaggerOperation(OperationId = "getTeamApplicationInstances")]
         public async Task<IActionResult> GetInstancesByTeam(Guid id, CancellationToken ct)
         {
-            var list = await _applicationService.GetInstancesByTeamAsync(id, ct);
+            var list = await _applicationService.GetInstancesByTeamAsync(id, skipVerification: false, ct);
             return Ok(list);
         }
 
@@ -339,6 +339,44 @@ public async Task<IActionResult> DeleteApplicationInstance(Guid id, Cancellation
             return NoContent();
         }
 
+        /// <summary>
+        /// Moves an Application Instance up
+        /// </summary>
+        /// <remarks>
+        /// Moves an Application Instance up one spot in the list
+        /// <para />
+        /// Accessible only to a SuperUser or a User on an Admin Team in the Application Instances's Team's View
+        /// </remarks>
+        /// <param name="id">The id of the Application Instance</param>
+        /// <param name="ct"></param>
+        [HttpPost("application-instances/{id}/move-up")]
+        [ProducesResponseType(typeof(IEnumerable<ApplicationInstance>), (int)HttpStatusCode.OK)]
+        [SwaggerOperation(OperationId = "moveUpApplicationInstance")]
+        public async Task<IActionResult> MoveUpApplicationInstance([FromRoute] Guid id, CancellationToken ct)
+        {
+            var updatedInstances = await _applicationService.MoveUpInstanceAsync(id, ct);
+            return Ok(updatedInstances);
+        }
+
+        /// <summary>
+        /// Moves an Application Instance down
+        /// </summary>
+        /// <remarks>
+        /// Moves an Application Instance down one spot in the list
+        /// <para />
+        /// Accessible only to a SuperUser or a User on an Admin Team in the Application Instances's Team's View
+        /// </remarks>
+        /// <param name="id">The id of the Application Instance</param>
+        /// <param name="ct"></param>
+        [HttpPost("application-instances/{id}/move-down")]
+        [ProducesResponseType(typeof(IEnumerable<ApplicationInstance>), (int)HttpStatusCode.OK)]
+        [SwaggerOperation(OperationId = "moveDownApplicationInstance")]
+        public async Task<IActionResult> MoveDownApplicationInstance([FromRoute] Guid id, CancellationToken ct)
+        {
+            var updatedInstances = await _applicationService.MoveDownInstanceAsync(id, ct);
+            return Ok(updatedInstances);
+        }
+
         #endregion
     }
 }

Player.Api/Services/ApplicationService.cs

@@ -37,10 +37,12 @@ public interface IApplicationService
         Task<bool> DeleteApplicationAsync(Guid id, CancellationToken ct);
 
         // Application Instances
-        Task<IEnumerable<ViewModels.ApplicationInstance>> GetInstancesByTeamAsync(Guid teamId, CancellationToken ct);
+        Task<IEnumerable<ViewModels.ApplicationInstance>> GetInstancesByTeamAsync(Guid teamId, bool skipVerification, CancellationToken ct);
         Task<ViewModels.ApplicationInstance> GetInstanceAsync(Guid id, CancellationToken ct);
         Task<ViewModels.ApplicationInstance> CreateInstanceAsync(Guid teamId, ViewModels.ApplicationInstanceForm instance, CancellationToken ct);
         Task<ViewModels.ApplicationInstance> UpdateInstanceAsync(Guid id, ViewModels.ApplicationInstanceForm instance, CancellationToken ct);
+        Task<IEnumerable<ViewModels.ApplicationInstance>> MoveUpInstanceAsync(Guid id, CancellationToken ct);
+        Task<IEnumerable<ViewModels.ApplicationInstance>> MoveDownInstanceAsync(Guid id, CancellationToken ct);
         Task<bool> DeleteInstanceAsync(Guid id, CancellationToken ct);
     }
 
@@ -225,24 +227,27 @@ public async Task<bool> DeleteApplicationAsync(Guid id, CancellationToken ct)
 
         #region Application Instances
 
-        public async Task<IEnumerable<ViewModels.ApplicationInstance>> GetInstancesByTeamAsync(Guid teamId, CancellationToken ct)
+        public async Task<IEnumerable<ViewModels.ApplicationInstance>> GetInstancesByTeamAsync(Guid teamId, bool skipVerification, CancellationToken ct)
         {
-            var team = await _context.Teams
+            if (!skipVerification)
+            {
+                var team = await _context.Teams
                 .Where(e => e.Id == teamId)
                 .SingleOrDefaultAsync(ct);
 
+                if (team == null)
+                    throw new EntityNotFoundException<Team>();
+
+                if (!(await _authorizationService.AuthorizeAsync(_user, null, new TeamAccessRequirement(team.ViewId, teamId))).Succeeded)
+                    throw new ForbiddenException();
+            }
+
             var instances = await _context.ApplicationInstances
                 .Where(i => i.TeamId == teamId)
                 .OrderBy(a => a.DisplayOrder)
                 .ProjectTo<ViewModels.ApplicationInstance>(_mapper.ConfigurationProvider)
                 .ToArrayAsync(ct);
 
-            if (team == null)
-                throw new EntityNotFoundException<Team>();
-
-            if (!(await _authorizationService.AuthorizeAsync(_user, null, new TeamAccessRequirement(team.ViewId, teamId))).Succeeded)
-                throw new ForbiddenException();
-
             return instances;
         }
 
@@ -322,6 +327,91 @@ public async Task<bool> DeleteInstanceAsync(Guid id, CancellationToken ct)
             return true;
         }
 
+        public async Task<IEnumerable<ViewModels.ApplicationInstance>> MoveUpInstanceAsync(Guid id, CancellationToken ct)
+        {
+            return await this.MoveInstanceAsync(id, Direction.Up, ct);
+        }
+
+        public async Task<IEnumerable<ViewModels.ApplicationInstance>> MoveDownInstanceAsync(Guid id, CancellationToken ct)
+        {
+            return await this.MoveInstanceAsync(id, Direction.Down, ct);
+        }
+
+        private enum Direction
+        {
+            Up,
+            Down
+        }
+
+        private async Task<IEnumerable<ViewModels.ApplicationInstance>> MoveInstanceAsync(Guid id, Direction direction, CancellationToken ct)
+        {
+            var instanceToUpdate = await _context.ApplicationInstances
+                .Include(x => x.Team)
+                .SingleOrDefaultAsync(x => x.Id == id, ct);
+
+            if (instanceToUpdate == null)
+                throw new EntityNotFoundException<ApplicationInstance>();
+
+            if (!(await _authorizationService.AuthorizeAsync(_user, null, new ViewAdminRequirement(instanceToUpdate.Team.ViewId))).Succeeded)
+                throw new ForbiddenException();
+
+            var teamInstances = await _context.ApplicationInstances
+                .Where(x => x.TeamId == instanceToUpdate.TeamId)
+                .OrderBy(x => x.DisplayOrder)
+                .ToArrayAsync(ct);
+
+            if (direction == Direction.Up)
+            {
+                for (int i = 0; i < teamInstances.Length; i++)
+                {
+                    var teamInstance = teamInstances[i];
+
+                    if (teamInstance.Id == id)
+                    {
+                        teamInstance.DisplayOrder = i - 1;
+
+                        var previous = teamInstances.ElementAtOrDefault(i - 1);
+
+                        if (previous != null)
+                        {
+                            previous.DisplayOrder = previous.DisplayOrder + 1;
+                        }
+                    }
+                    else
+                    {
+                        teamInstance.DisplayOrder = i;
+                    }
+                }
+            }
+            else if (direction == Direction.Down)
+            {
+                for (int i = teamInstances.Length - 1; i >= 0; i--)
+                {
+                    var teamInstance = teamInstances[i];
+
+                    if (teamInstance.Id == id)
+                    {
+                        teamInstance.DisplayOrder = i + 1;
+
+                        var previous = teamInstances.ElementAtOrDefault(i + 1);
+
+                        if (previous != null)
+                        {
+                            previous.DisplayOrder = previous.DisplayOrder - 1;
+                        }
+                    }
+                    else
+                    {
+                        teamInstance.DisplayOrder = i;
+                    }
+                }
+            }
+
+            await _context.SaveChangesAsync(ct);
+
+            return await this.GetInstancesByTeamAsync(instanceToUpdate.TeamId, skipVerification: true, ct);
+        }
+
         #endregion
     }
 }