< Summary

Class:DCl.Social.Friends.RPCFriendsApiBridge
Assembly:FriendsController
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Controllers/FriendsController/RPCFriendsApiBridge.cs
Covered lines:0
Uncovered lines:104
Coverable lines:104
Total lines:430
Line coverage:0% (0 of 104)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
add_OnInitialized(...)0%2100%
remove_OnInitialized(...)0%2100%
add_OnFriendNotFound(...)0%2100%
remove_OnFriendNotFound(...)0%2100%
add_OnFriendRequestsAdded(...)0%2100%
remove_OnFriendRequestsAdded(...)0%2100%
add_OnFriendWithDirectMessagesAdded(...)0%2100%
remove_OnFriendWithDirectMessagesAdded(...)0%2100%
add_OnUserPresenceUpdated(...)0%2100%
remove_OnUserPresenceUpdated(...)0%2100%
add_OnTotalFriendRequestCountUpdated(...)0%2100%
remove_OnTotalFriendRequestCountUpdated(...)0%2100%
add_OnTotalFriendCountUpdated(...)0%2100%
remove_OnTotalFriendCountUpdated(...)0%2100%
CreateSharedInstance(...)0%2100%
RegisterService(...)0%2100%
RPCFriendsApiBridge(...)0%2100%
RejectFriendship(...)0%2100%
RejectFriendshipAsync()0%1561200%
RemoveFriend(...)0%2100%
GetFriendsAsync(...)0%2100%
GetFriendsAsync(...)0%2100%
GetFriendRequests(...)0%2100%
GetFriendRequestsAsync()0%1561200%
GetFriendsWithDirectMessages(...)0%2100%
RequestFriendship(...)0%2100%
RequestFriendshipAsync()0%1561200%
CancelRequestAsync()0%1561200%
CancelRequestByUserIdAsync(...)0%2100%
CancelRequestByUserId(...)0%2100%
AcceptFriendship(...)0%2100%
ApproveFriendRequest(...)0%6200%
RejectFriendRequest(...)0%6200%
CancelFriendRequest()0%20400%
ReceiveFriendRequest()0%30500%
AcceptFriendshipAsync()0%1561200%
GetFriendshipStatus()0%1321100%
ToFriendshipStatus(...)0%30500%
ToFriendRequestPayload(...)0%2100%
ToErrorCode(...)0%42600%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Controllers/FriendsController/RPCFriendsApiBridge.cs

#LineLine coverage
 1using Cysharp.Threading.Tasks;
 2using DCL;
 3using DCL.Helpers;
 4using DCL.Social.Friends;
 5using Decentraland.Renderer.KernelServices;
 6using Decentraland.Renderer.RendererServices;
 7using Decentraland.Renderer.Common;
 8using JetBrains.Annotations;
 9using RPC;
 10using rpc_csharp;
 11using System;
 12using System.Linq;
 13using System.Threading;
 14using FriendshipStatus = DCL.Social.Friends.FriendshipStatus;
 15using KernelGetFriendRequestsPayload = Decentraland.Renderer.KernelServices.GetFriendRequestsPayload;
 16using KernelRejectFriendRequestReply = Decentraland.Renderer.KernelServices.RejectFriendRequestReply;
 17using KernelRejectFriendRequestPayload = Decentraland.Renderer.KernelServices.RejectFriendRequestPayload;
 18using KernelCancelFriendRequestReply = Decentraland.Renderer.KernelServices.CancelFriendRequestReply;
 19using KernelCancelFriendRequestPayload = Decentraland.Renderer.KernelServices.CancelFriendRequestPayload;
 20using RendererRejectFriendRequestReply = Decentraland.Renderer.RendererServices.RejectFriendRequestReply;
 21using RendererRejectFriendRequestPayload = Decentraland.Renderer.RendererServices.RejectFriendRequestPayload;
 22using RendererCancelFriendRequestReply = Decentraland.Renderer.RendererServices.CancelFriendRequestReply;
 23using RendererCancelFriendRequestPayload = Decentraland.Renderer.RendererServices.CancelFriendRequestPayload;
 24using RPCFriendshipStatus = Decentraland.Renderer.KernelServices.FriendshipStatus;
 25
 26namespace DCl.Social.Friends
 27{
 28    public class RPCFriendsApiBridge : IFriendsApiBridge, IFriendRequestRendererService<RPCContext>
 29    {
 30        private const int REQUEST_TIMEOUT = 30;
 31
 32        private static RPCFriendsApiBridge i;
 33
 34        private readonly IRPC rpc;
 35        private readonly IFriendsApiBridge fallbackApiBridge;
 36
 37        public event Action<FriendshipInitializationMessage> OnInitialized
 38        {
 039            add => fallbackApiBridge.OnInitialized += value;
 040            remove => fallbackApiBridge.OnInitialized -= value;
 41        }
 42
 43        public event Action<string> OnFriendNotFound
 44        {
 045            add => fallbackApiBridge.OnFriendNotFound += value;
 046            remove => fallbackApiBridge.OnFriendNotFound -= value;
 47        }
 48
 49        public event Action<AddFriendRequestsPayload> OnFriendRequestsAdded
 50        {
 051            add => fallbackApiBridge.OnFriendRequestsAdded += value;
 052            remove => fallbackApiBridge.OnFriendRequestsAdded -= value;
 53        }
 54
 55        public event Action<AddFriendsWithDirectMessagesPayload> OnFriendWithDirectMessagesAdded
 56        {
 057            add => fallbackApiBridge.OnFriendWithDirectMessagesAdded += value;
 058            remove => fallbackApiBridge.OnFriendWithDirectMessagesAdded -= value;
 59        }
 60
 61        public event Action<UserStatus> OnUserPresenceUpdated
 62        {
 063            add => fallbackApiBridge.OnUserPresenceUpdated += value;
 064            remove => fallbackApiBridge.OnUserPresenceUpdated -= value;
 65        }
 66
 67        public event Action<FriendshipUpdateStatusMessage> OnFriendshipStatusUpdated;
 68
 69        public event Action<UpdateTotalFriendRequestsPayload> OnTotalFriendRequestCountUpdated
 70        {
 071            add => fallbackApiBridge.OnTotalFriendRequestCountUpdated += value;
 072            remove => fallbackApiBridge.OnTotalFriendRequestCountUpdated -= value;
 73        }
 74
 75        public event Action<UpdateTotalFriendsPayload> OnTotalFriendCountUpdated
 76        {
 077            add => fallbackApiBridge.OnTotalFriendCountUpdated += value;
 078            remove => fallbackApiBridge.OnTotalFriendCountUpdated -= value;
 79        }
 80
 81        public event Action<FriendRequestPayload> OnFriendRequestReceived;
 82
 83        public static RPCFriendsApiBridge CreateSharedInstance(IRPC rpc, IFriendsApiBridge fallbackApiBridge)
 84        {
 085            i = new RPCFriendsApiBridge(rpc, fallbackApiBridge);
 086            return i;
 87        }
 88
 89        public static void RegisterService(RpcServerPort<RPCContext> port)
 90        {
 091            FriendRequestRendererServiceCodeGen.RegisterService(port, i);
 092        }
 93
 094        public RPCFriendsApiBridge(IRPC rpc, IFriendsApiBridge fallbackApiBridge)
 95        {
 096            this.rpc = rpc;
 097            this.fallbackApiBridge = fallbackApiBridge;
 098        }
 99
 100        public void RejectFriendship(string userId) =>
 0101            fallbackApiBridge.RejectFriendship(userId);
 102
 103        public async UniTask<RejectFriendshipPayload> RejectFriendshipAsync(string friendRequestId, CancellationToken ca
 104        {
 105            try
 106            {
 0107                cancellationToken.ThrowIfCancellationRequested();
 108
 109                // TODO: pass cancellation token to rpc client when is supported
 0110                KernelRejectFriendRequestReply response = await rpc.FriendRequests()
 111                                                                   .RejectFriendRequest(new KernelRejectFriendRequestPay
 112                                                                    {
 113                                                                        FriendRequestId = friendRequestId
 114                                                                    }).Timeout(TimeSpan.FromSeconds(REQUEST_TIMEOUT));
 115
 0116                cancellationToken.ThrowIfCancellationRequested();
 117
 0118                RejectFriendshipPayload payload = response.MessageCase == KernelRejectFriendRequestReply.MessageOneofCas
 119                    ? new RejectFriendshipPayload
 120                    {
 121                        FriendRequestPayload = ToFriendRequestPayload(response.Reply.FriendRequest),
 122                    }
 123                    : throw new FriendshipException(ToErrorCode(response.Error));
 124
 0125                await UniTask.SwitchToMainThread(cancellationToken);
 126
 0127                return payload;
 128            }
 129            finally
 130            {
 0131                await UniTask.SwitchToMainThread();
 132            }
 0133        }
 134
 135        public void RemoveFriend(string userId) =>
 0136            fallbackApiBridge.RemoveFriend(userId);
 137
 138        public UniTask<AddFriendsPayload> GetFriendsAsync(int limit, int skip, CancellationToken cancellationToken = def
 0139            fallbackApiBridge.GetFriendsAsync(limit, skip, cancellationToken);
 140
 141        public UniTask<AddFriendsPayload> GetFriendsAsync(string usernameOrId, int limit, CancellationToken cancellation
 0142            fallbackApiBridge.GetFriendsAsync(usernameOrId, limit, cancellationToken);
 143
 144        public void GetFriendRequests(int sentLimit, int sentSkip, int receivedLimit, int receivedSkip) =>
 0145            fallbackApiBridge.GetFriendRequests(sentLimit, sentSkip, receivedLimit, receivedSkip);
 146
 147        public async UniTask<AddFriendRequestsV2Payload> GetFriendRequestsAsync(int sentLimit, int sentSkip,
 148            int receivedLimit, int receivedSkip,
 149            CancellationToken cancellationToken)
 150        {
 151            try
 152            {
 0153                cancellationToken.ThrowIfCancellationRequested();
 154
 155                // TODO: pass cancellation token to rpc client when is supported
 0156                GetFriendRequestsReply response = await rpc.FriendRequests()
 157                                                           .GetFriendRequests(new KernelGetFriendRequestsPayload
 158                                                            {
 159                                                                SentLimit = sentLimit,
 160                                                                SentSkip = sentSkip,
 161                                                                ReceivedLimit = receivedLimit,
 162                                                                ReceivedSkip = receivedSkip
 163                                                            })
 164                                                           .Timeout(TimeSpan.FromSeconds(REQUEST_TIMEOUT));
 165
 0166                cancellationToken.ThrowIfCancellationRequested();
 167
 0168                AddFriendRequestsV2Payload payload = response.MessageCase == GetFriendRequestsReply.MessageOneofCase.Err
 169                    ? throw new FriendshipException(ToErrorCode(response.Error))
 170                    : new AddFriendRequestsV2Payload
 171                    {
 172                        requestedTo = response.Reply.RequestedTo.Select(ToFriendRequestPayload).ToArray(),
 173                        requestedFrom = response.Reply.RequestedFrom.Select(ToFriendRequestPayload).ToArray(),
 174                        totalReceivedFriendRequests = response.Reply.TotalReceivedFriendRequests,
 175                        totalSentFriendRequests = response.Reply.TotalSentFriendRequests,
 176                    };
 177
 0178                await UniTask.SwitchToMainThread(cancellationToken);
 179
 0180                return payload;
 181            }
 182            finally
 183            {
 0184                await UniTask.SwitchToMainThread();
 185            }
 0186        }
 187
 188        public void GetFriendsWithDirectMessages(string usernameOrId, int limit, int skip) =>
 0189            fallbackApiBridge.GetFriendsWithDirectMessages(usernameOrId, limit, skip);
 190
 191        public void RequestFriendship(string friendUserId) =>
 0192            fallbackApiBridge.RequestFriendship(friendUserId);
 193
 194        public async UniTask<RequestFriendshipConfirmationPayload> RequestFriendshipAsync(string userId, string messageB
 195            CancellationToken cancellationToken)
 196        {
 197            try
 198            {
 0199                cancellationToken.ThrowIfCancellationRequested();
 200
 201                // TODO: pass cancellation token to rpc client when is supported
 0202                SendFriendRequestReply reply = await rpc.FriendRequests()
 203                                                        .SendFriendRequest(new SendFriendRequestPayload
 204                                                         {
 205                                                             MessageBody = messageBody,
 206                                                             UserId = userId,
 207                                                         })
 208                                                        .Timeout(TimeSpan.FromSeconds(REQUEST_TIMEOUT));
 209
 0210                cancellationToken.ThrowIfCancellationRequested();
 211
 0212                RequestFriendshipConfirmationPayload payload = reply.MessageCase == SendFriendRequestReply.MessageOneofC
 213                    ? new RequestFriendshipConfirmationPayload
 214                    {
 215                        friendRequest = ToFriendRequestPayload(reply.Reply.FriendRequest),
 216                    }
 217                    : throw new FriendshipException(ToErrorCode(reply.Error));
 218
 0219                await UniTask.SwitchToMainThread(cancellationToken);
 220
 0221                return payload;
 222            }
 223            finally
 224            {
 0225                await UniTask.SwitchToMainThread();
 226            }
 0227        }
 228
 229        public async UniTask<CancelFriendshipConfirmationPayload> CancelRequestAsync(string friendRequestId,
 230            CancellationToken cancellationToken)
 231        {
 232            try
 233            {
 0234                cancellationToken.ThrowIfCancellationRequested();
 235
 236                // TODO: pass cancellation token to rpc client when is supported
 0237                KernelCancelFriendRequestReply reply = await rpc.FriendRequests()
 238                                                                .CancelFriendRequest(new KernelCancelFriendRequestPayloa
 239                                                                 {
 240                                                                     FriendRequestId = friendRequestId
 241                                                                 }).Timeout(TimeSpan.FromSeconds(REQUEST_TIMEOUT));
 242
 0243                cancellationToken.ThrowIfCancellationRequested();
 244
 0245                CancelFriendshipConfirmationPayload payload = reply.MessageCase == KernelCancelFriendRequestReply.Messag
 246                    ? new CancelFriendshipConfirmationPayload
 247                    {
 248                        friendRequest = ToFriendRequestPayload(reply.Reply.FriendRequest),
 249                    }
 250                    : throw new FriendshipException(ToErrorCode(reply.Error));
 251
 0252                await UniTask.SwitchToMainThread(cancellationToken);
 253
 0254                return payload;
 255            }
 256            finally
 257            {
 0258                await UniTask.SwitchToMainThread(cancellationToken);
 259            }
 0260        }
 261
 262        public UniTask CancelRequestByUserIdAsync(string userId, CancellationToken cancellationToken) =>
 0263            fallbackApiBridge.CancelRequestByUserIdAsync(userId, cancellationToken);
 264
 265        public void CancelRequestByUserId(string userId) =>
 0266            fallbackApiBridge.CancelRequestByUserId(userId);
 267
 268        public void AcceptFriendship(string userId) =>
 0269            fallbackApiBridge.AcceptFriendship(userId);
 270
 271        [PublicAPI]
 272        public UniTask<ApproveFriendRequestReply> ApproveFriendRequest(ApproveFriendRequestPayload request, RPCContext c
 273        {
 0274            OnFriendshipStatusUpdated?.InvokeOnMainThread(new FriendshipUpdateStatusMessage
 275            {
 276                action = FriendshipAction.APPROVED,
 277                userId = request.UserId
 278            });
 279
 0280            return UniTask.FromResult(new ApproveFriendRequestReply());
 281        }
 282
 283        [PublicAPI]
 284        public UniTask<RendererRejectFriendRequestReply> RejectFriendRequest(RendererRejectFriendRequestPayload request,
 285        {
 0286            OnFriendshipStatusUpdated?.InvokeOnMainThread(new FriendshipUpdateStatusMessage
 287            {
 288                action = FriendshipAction.REJECTED,
 289                userId = request.UserId
 290            });
 291
 0292            return UniTask.FromResult(new RendererRejectFriendRequestReply());
 293        }
 294
 295        [PublicAPI]
 296        public async UniTask<RendererCancelFriendRequestReply> CancelFriendRequest(RendererCancelFriendRequestPayload re
 297        {
 0298            await UniTask.SwitchToMainThread(ct);
 299
 0300            OnFriendshipStatusUpdated?.Invoke(new FriendshipUpdateStatusMessage
 301            {
 302                action = FriendshipAction.CANCELLED,
 303                userId = request.UserId
 304            });
 305
 0306            return new RendererCancelFriendRequestReply();
 0307        }
 308
 309        [PublicAPI]
 310        public async UniTask<ReceiveFriendRequestReply> ReceiveFriendRequest(ReceiveFriendRequestPayload request, RPCCon
 311        {
 0312            await UniTask.SwitchToMainThread(ct);
 313
 0314            OnFriendRequestReceived?.Invoke(ToFriendRequestPayload(request.FriendRequest));
 315
 0316            OnFriendshipStatusUpdated?.Invoke(new FriendshipUpdateStatusMessage
 317            {
 318                action = FriendshipAction.REQUESTED_FROM,
 319                userId = request.FriendRequest.From
 320            });
 321
 0322            return new ReceiveFriendRequestReply();
 0323        }
 324
 325        public async UniTask<AcceptFriendshipPayload> AcceptFriendshipAsync(string friendRequestId, CancellationToken ca
 326        {
 327            try
 328            {
 0329                cancellationToken.ThrowIfCancellationRequested();
 330
 331                // TODO: pass cancellation token to rpc client when is supported
 0332                AcceptFriendRequestReply response = await rpc.FriendRequests()
 333                                                             .AcceptFriendRequest(new AcceptFriendRequestPayload
 334                                                              {
 335                                                                  FriendRequestId = friendRequestId
 336                                                              }).Timeout(TimeSpan.FromSeconds(REQUEST_TIMEOUT));
 337
 0338                cancellationToken.ThrowIfCancellationRequested();
 339
 0340                AcceptFriendshipPayload payload = response.MessageCase == AcceptFriendRequestReply.MessageOneofCase.Repl
 341                    ? new AcceptFriendshipPayload
 342                    {
 343                        FriendRequest = ToFriendRequestPayload(response.Reply.FriendRequest)
 344                    }
 345                    : throw new FriendshipException(ToErrorCode(response.Error));
 346
 0347                await UniTask.SwitchToMainThread(cancellationToken);
 348
 0349                return payload;
 350            }
 351            finally
 352            {
 0353                await UniTask.SwitchToMainThread();
 354            }
 0355        }
 356
 357        public async UniTask<FriendshipStatus> GetFriendshipStatus(string userId, CancellationToken cancellationToken)
 358        {
 359            try
 360            {
 0361                cancellationToken.ThrowIfCancellationRequested();
 362
 363                // TODO: pass cancellation token to rpc client when is supported
 0364                GetFriendshipStatusResponse response = await rpc.Friends()
 365                                                                .GetFriendshipStatus(new GetFriendshipStatusRequest
 366                                                                 {
 367                                                                     UserId = userId
 368                                                                 });
 369
 0370                cancellationToken.ThrowIfCancellationRequested();
 371
 0372                FriendshipStatus status = ToFriendshipStatus(response.Status);
 373
 0374                await UniTask.SwitchToMainThread(cancellationToken);
 375
 0376                return status;
 377            }
 378            finally
 379            {
 0380                await UniTask.SwitchToMainThread();
 381            }
 0382        }
 383
 384        private FriendshipStatus ToFriendshipStatus(RPCFriendshipStatus status)
 385        {
 386            switch (status)
 387            {
 388                case RPCFriendshipStatus.Approved:
 0389                    return FriendshipStatus.FRIEND;
 390                case RPCFriendshipStatus.None:
 391                default:
 0392                    return FriendshipStatus.NOT_FRIEND;
 393                case RPCFriendshipStatus.RequestedFrom:
 0394                    return FriendshipStatus.REQUESTED_FROM;
 395                case RPCFriendshipStatus.RequestedTo:
 0396                    return FriendshipStatus.REQUESTED_TO;
 397            }
 398        }
 399
 400        private static FriendRequestPayload ToFriendRequestPayload(FriendRequestInfo request) =>
 0401            new()
 402            {
 403                from = request.From,
 404                timestamp = (long)request.Timestamp,
 405                to = request.To,
 406                messageBody = request.MessageBody,
 407                friendRequestId = request.FriendRequestId
 408            };
 409
 410        private FriendRequestErrorCodes ToErrorCode(FriendshipErrorCode code)
 411        {
 412            switch (code)
 413            {
 414                default:
 415                case FriendshipErrorCode.FecUnknown:
 0416                    return FriendRequestErrorCodes.Unknown;
 417                case FriendshipErrorCode.FecBlockedUser:
 0418                    return FriendRequestErrorCodes.BlockedUser;
 419                case FriendshipErrorCode.FecInvalidRequest:
 0420                    return FriendRequestErrorCodes.InvalidRequest;
 421                case FriendshipErrorCode.FecNonExistingUser:
 0422                    return FriendRequestErrorCodes.NonExistingUser;
 423                case FriendshipErrorCode.FecNotEnoughTimePassed:
 0424                    return FriendRequestErrorCodes.NotEnoughTimePassed;
 425                case FriendshipErrorCode.FecTooManyRequestsSent:
 0426                    return FriendRequestErrorCodes.TooManyRequestsSent;
 427            }
 428        }
 429    }
 430}
Generated by: ReportGenerator 4.8.9.0
02/03/2023 - 18:35:20
GitHub | www.palmmedia.de

Methods/Properties

add_OnInitialized(System.Action[FriendshipInitializationMessage])
remove_OnInitialized(System.Action[FriendshipInitializationMessage])
add_OnFriendNotFound(System.Action[String])
remove_OnFriendNotFound(System.Action[String])
add_OnFriendRequestsAdded(System.Action[AddFriendRequestsPayload])
remove_OnFriendRequestsAdded(System.Action[AddFriendRequestsPayload])
add_OnFriendWithDirectMessagesAdded(System.Action[AddFriendsWithDirectMessagesPayload])
remove_OnFriendWithDirectMessagesAdded(System.Action[AddFriendsWithDirectMessagesPayload])
add_OnUserPresenceUpdated(System.Action[UserStatus])
remove_OnUserPresenceUpdated(System.Action[UserStatus])
add_OnTotalFriendRequestCountUpdated(System.Action[UpdateTotalFriendRequestsPayload])
remove_OnTotalFriendRequestCountUpdated(System.Action[UpdateTotalFriendRequestsPayload])
add_OnTotalFriendCountUpdated(System.Action[UpdateTotalFriendsPayload])
remove_OnTotalFriendCountUpdated(System.Action[UpdateTotalFriendsPayload])
CreateSharedInstance(DCL.IRPC, DCl.Social.Friends.IFriendsApiBridge)
RegisterService(rpc_csharp.RpcServerPort[RPCContext])
RPCFriendsApiBridge(DCL.IRPC, DCl.Social.Friends.IFriendsApiBridge)
RejectFriendship(System.String)
RejectFriendshipAsync()
RemoveFriend(System.String)
GetFriendsAsync(System.Int32, System.Int32, System.Threading.CancellationToken)
GetFriendsAsync(System.String, System.Int32, System.Threading.CancellationToken)
GetFriendRequests(System.Int32, System.Int32, System.Int32, System.Int32)
GetFriendRequestsAsync()
GetFriendsWithDirectMessages(System.String, System.Int32, System.Int32)
RequestFriendship(System.String)
RequestFriendshipAsync()
CancelRequestAsync()
CancelRequestByUserIdAsync(System.String, System.Threading.CancellationToken)
CancelRequestByUserId(System.String)
AcceptFriendship(System.String)
ApproveFriendRequest(Decentraland.Renderer.RendererServices.ApproveFriendRequestPayload, RPC.RPCContext, System.Threading.CancellationToken)
RejectFriendRequest(Decentraland.Renderer.RendererServices.RejectFriendRequestPayload, RPC.RPCContext, System.Threading.CancellationToken)
CancelFriendRequest()
ReceiveFriendRequest()
AcceptFriendshipAsync()
GetFriendshipStatus()
ToFriendshipStatus(Decentraland.Renderer.KernelServices.FriendshipStatus)
ToFriendRequestPayload(Decentraland.Renderer.Common.FriendRequestInfo)
ToErrorCode(Decentraland.Renderer.Common.FriendshipErrorCode)