Shares rework (#194)

Co-authored-by: LucHeart <luc@luc.cat>

Author: hhvrc

API/Controller/Devices/DevicesController.cs

@@ -228,7 +228,7 @@ public async Task<IActionResult> GetLiveControlGatewayInfo([FromRoute] Guid devi
     {
         // Check if user owns device or has a share
         var deviceExistsAndYouHaveAccess = await _db.Devices.AnyAsync(x =>
-            x.Id == deviceId && (x.OwnerId == CurrentUser.Id || x.Shockers.Any(y => y.ShockerShares.Any(
+            x.Id == deviceId && (x.OwnerId == CurrentUser.Id || x.Shockers.Any(y => y.UserShares.Any(
                 z => z.SharedWithUserId == CurrentUser.Id))));
         if (!deviceExistsAndYouHaveAccess) return Problem(DeviceError.DeviceNotFound);
 

API/Controller/Shares/LinkShareCode.cs

@@ -37,13 +37,13 @@ [FromServices] IDeviceUpdateService deviceUpdateService
         }).FirstOrDefaultAsync();
         if (shareCode == null) return Problem(ShareCodeError.ShareCodeNotFound);
         if (shareCode.OwnerId == CurrentUser.Id) return Problem(ShareCodeError.CantLinkOwnShareCode);
-        if (await _db.ShockerShares.AnyAsync(x => x.ShockerId == shareCode.Share.ShockerId && x.SharedWithUserId == CurrentUser.Id))
+        if (await _db.UserShares.AnyAsync(x => x.ShockerId == shareCode.Share.ShockerId && x.SharedWithUserId == CurrentUser.Id))
             return Problem(ShareCodeError.ShockerAlreadyLinked);
 
-        _db.ShockerShares.Add(new ShockerShare
+        _db.UserShares.Add(new UserShare
         {
-            ShockerId = shareCode.Share.ShockerId,
             SharedWithUserId = CurrentUser.Id,
+            ShockerId = shareCode.Share.ShockerId,
             AllowShock = shareCode.Share.AllowShock,
             AllowVibrate = shareCode.Share.AllowVibrate,
             AllowSound = shareCode.Share.AllowSound,

…ontroller/Shares/V2CreateShareRequest.cs …Controller/Shares/V2CreateShareInvite.csAPI/Controller/Shares/V2CreateShareRequest.cs renamed to API/Controller/Shares/V2CreateShareInvite.cs API/Controller/Shares/V2CreateShareRequest.cs renamed to API/Controller/Shares/V2CreateShareInvite.cs

@@ -12,25 +12,25 @@ namespace OpenShock.API.Controller.Shares;
 
 public sealed partial class SharesController
 {
-    [HttpPost("requests")]
+    [HttpPost("invites")]
     [ProducesResponseType<Guid>(StatusCodes.Status200OK, MediaTypeNames.Text.Plain)]
     [ProducesResponseType<OpenShockProblem>(StatusCodes.Status404NotFound, MediaTypeNames.Application.ProblemJson)] // UserNotFound, ShareCreateShockerNotFound
     [ProducesResponseType<OpenShockProblem>(StatusCodes.Status400BadRequest, MediaTypeNames.Application.ProblemJson)] // ShareCreateCannotShareWithSelf
     [ApiVersion("2")]
-    public async Task<IActionResult> CreateShare([FromBody] CreateShareRequest data)
+    public async Task<IActionResult> CreateShareInvite([FromBody] CreateShareRequest body)
     {
-        if (data.User == CurrentUser.Id)
+        if (body.User == CurrentUser.Id)
         {
             return Problem(ShareError.ShareRequestCreateCannotShareWithSelf);
         }
 
-        var providedShockerIds = data.Shockers.Select(x => x.Id).ToArray();
+        var providedShockerIds = body.Shockers.Select(x => x.Id).ToArray();
         var belongsToUsFuture = _db.Shockers.AsNoTracking().Where(x =>
             x.Device.OwnerId == CurrentUser.Id && providedShockerIds.Contains(x.Id)).Select(x => x.Id).Future();
 
-        if (data.User != null)
+        if (body.User != null)
         {
-            var existsFuture = _db.Users.AsNoTracking().DeferredAny(x => x.Id == data.User).FutureValue();
+            var existsFuture = _db.Users.AsNoTracking().DeferredAny(x => x.Id == body.User).FutureValue();
 
             // We can already resolve the futures here since this is the last future query
             if (!await existsFuture.ValueAsync()) return Problem(UserError.UserNotFound);
@@ -47,26 +47,26 @@ public async Task<IActionResult> CreateShare([FromBody] CreateShareRequest data)
 
         await using var transaction = await _db.Database.BeginTransactionAsync();
 
-        var shareRequest = new ShareRequest
+        var shareInvite = new UserShareInvite
         {
             Id = Guid.CreateVersion7(),
             OwnerId = CurrentUser.Id,
-            UserId = data.User
+            RecipientUserId = body.User
         };
-        _db.ShareRequests.Add(shareRequest);
+        _db.UserShareInvites.Add(shareInvite);
 
-        foreach (var createShockerShare in data.Shockers)
+        foreach (var createUserShare in body.Shockers)
         {
-            _db.ShareRequestShockerMappings.Add(new ShareRequestShocker
+            _db.UserShareInviteShockers.Add(new UserShareInviteShocker
             {
-                ShareRequestId = shareRequest.Id,
-                ShockerId = createShockerShare.Id,
-                AllowShock = createShockerShare.Permissions.Shock,
-                AllowVibrate = createShockerShare.Permissions.Vibrate,
-                AllowSound = createShockerShare.Permissions.Sound,
-                AllowLiveControl = createShockerShare.Permissions.Live,
-                MaxIntensity = createShockerShare.Limits.Intensity,
-                MaxDuration = createShockerShare.Limits.Duration,
+                InviteId = shareInvite.Id,
+                ShockerId = createUserShare.Id,
+                AllowShock = createUserShare.Permissions.Shock,
+                AllowVibrate = createUserShare.Permissions.Vibrate,
+                AllowSound = createUserShare.Permissions.Sound,
+                AllowLiveControl = createUserShare.Permissions.Live,
+                MaxIntensity = createUserShare.Limits.Intensity,
+                MaxDuration = createUserShare.Limits.Duration,
                 IsPaused = false
             });
         }
@@ -75,6 +75,6 @@ public async Task<IActionResult> CreateShare([FromBody] CreateShareRequest data)
 
         await transaction.CommitAsync();
 
-        return Ok(shareRequest.Id);
+        return Ok(shareInvite.Id);
     }
 }

API/Controller/Shares/V2GetShares.cs

@@ -3,23 +3,25 @@
 using Microsoft.EntityFrameworkCore;
 using OpenShock.API.Models.Response;
 using OpenShock.Common.Extensions;
+using Z.EntityFramework.Plus;
 
 namespace OpenShock.API.Controller.Shares;
 
 public sealed partial class SharesController
 {
     [HttpGet]
     [ApiVersion("2")]
-    public IAsyncEnumerable<V2UserSharesListItem> GetSharesByUsers()
+    public async Task<V2UserShares> GetSharesByUsers(CancellationToken cancellationToken)
     {
-        return _db.ShockerShares
+        _db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
+
+        var outgoingSharesFuture = _db.UserShares
             .Where(x => x.Shocker.Device.OwnerId == CurrentUser.Id)
-            .AsNoTracking()
             .GroupBy(x => x.SharedWithUserId)
-            .Select(g => new V2UserSharesListItem
+            .Select(g => new V2UserSharesListItemDto
             {
                 Id = g.Key,
-                Image = g.First().SharedWithUser.GetImageUrl(),
+                Email = g.First().SharedWithUser.Email,
                 Name = g.First().SharedWithUser.Name,
                 Shares = g.Select(y => new UserShareInfo
                     {
@@ -42,6 +44,49 @@ public IAsyncEnumerable<V2UserSharesListItem> GetSharesByUsers()
                     })
                     .ToArray()
             })
-            .AsAsyncEnumerable();
+            .Future();
+
+        var incomingSharesFuture = _db.UserShares
+            .Where(x => x.SharedWithUserId == CurrentUser.Id)
+            .GroupBy(x => x.Shocker.Device.OwnerId)
+            .Select(g => new V2UserSharesListItemDto
+            {
+                Id = g.Key,
+                Email = g.First().Shocker.Device.Owner.Email,
+                Name = g.First().Shocker.Device.Owner.Name,
+                Shares = g.Select(y => new UserShareInfo
+                    {
+                        Id = y.Shocker.Id,
+                        Name = y.Shocker.Name,
+                        CreatedOn = y.CreatedAt,
+                        Permissions = new ShockerPermissions
+                        {
+                            Sound = y.AllowSound,
+                            Vibrate = y.AllowVibrate,
+                            Shock = y.AllowShock,
+                            Live = y.AllowLiveControl
+                        },
+                        Limits = new ShockerLimits
+                        {
+                            Duration = y.MaxDuration,
+                            Intensity = y.MaxIntensity
+                        },
+                        Paused = y.IsPaused
+                    })
+                    .ToArray()
+            })
+            .Future();
+
+        return new V2UserShares
+        {
+            Outgoing = (await outgoingSharesFuture.ToArrayAsync(cancellationToken)).Select(x => x.FromDto()),
+            Incoming = (await incomingSharesFuture.ToArrayAsync(cancellationToken)).Select(x => x.FromDto())
+        };
+    }
+
+    public sealed class V2UserShares
+    {
+        public required IEnumerable<V2UserSharesListItem> Outgoing { get; set; }
+        public required IEnumerable<V2UserSharesListItem> Incoming { get; set; }
     }
 }