< 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:20
Uncovered lines:78
Coverable lines:98
Total lines:408
Line coverage:20.4% (20 of 98)
Covered branches:0
Total branches:0
Covered methods:16
Total methods:34
Method coverage:47% (16 of 34)

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
add_OnInitialized(...)0%110100%
remove_OnInitialized(...)0%110100%
add_OnFriendNotFound(...)0%110100%
remove_OnFriendNotFound(...)0%110100%
add_OnFriendRequestsAdded(...)0%110100%
remove_OnFriendRequestsAdded(...)0%110100%
add_OnFriendWithDirectMessagesAdded(...)0%110100%
remove_OnFriendWithDirectMessagesAdded(...)0%110100%
add_OnUserPresenceUpdated(...)0%110100%
remove_OnUserPresenceUpdated(...)0%110100%
add_OnTotalFriendRequestCountUpdated(...)0%110100%
remove_OnTotalFriendRequestCountUpdated(...)0%110100%
add_OnTotalFriendCountUpdated(...)0%110100%
remove_OnTotalFriendCountUpdated(...)0%110100%
CreateSharedInstance(...)0%110100%
RegisterService(...)0%2100%
RPCFriendsApiBridge(...)0%110100%
RejectFriendshipAsync()0%1561200%
RemoveFriend(...)0%2100%
GetFriendsAsync(...)0%2100%
GetFriendsAsync(...)0%2100%
GetFriendRequestsAsync()0%1561200%
GetFriendsWithDirectMessages(...)0%2100%
RequestFriendshipAsync()0%1561200%
CancelRequestAsync()0%1561200%
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        {
 1939            add => fallbackApiBridge.OnInitialized += value;
 42340            remove => fallbackApiBridge.OnInitialized -= value;
 41        }
 42
 43        public event Action<string> OnFriendNotFound
 44        {
 1945            add => fallbackApiBridge.OnFriendNotFound += value;
 42346            remove => fallbackApiBridge.OnFriendNotFound -= value;
 47        }
 48
 49        public event Action<AddFriendRequestsPayload> OnFriendRequestsAdded
 50        {
 1951            add => fallbackApiBridge.OnFriendRequestsAdded += value;
 42352            remove => fallbackApiBridge.OnFriendRequestsAdded -= value;
 53        }
 54
 55        public event Action<AddFriendsWithDirectMessagesPayload> OnFriendWithDirectMessagesAdded
 56        {
 42357            add => fallbackApiBridge.OnFriendWithDirectMessagesAdded += value;
 42358            remove => fallbackApiBridge.OnFriendWithDirectMessagesAdded -= value;
 59        }
 60
 61        public event Action<UserStatus> OnUserPresenceUpdated
 62        {
 42363            add => fallbackApiBridge.OnUserPresenceUpdated += value;
 42364            remove => fallbackApiBridge.OnUserPresenceUpdated -= value;
 65        }
 66
 67        public event Action<FriendshipUpdateStatusMessage> OnFriendshipStatusUpdated;
 68
 69        public event Action<UpdateTotalFriendRequestsPayload> OnTotalFriendRequestCountUpdated
 70        {
 1971            add => fallbackApiBridge.OnTotalFriendRequestCountUpdated += value;
 42372            remove => fallbackApiBridge.OnTotalFriendRequestCountUpdated -= value;
 73        }
 74
 75        public event Action<UpdateTotalFriendsPayload> OnTotalFriendCountUpdated
 76        {
 1977            add => fallbackApiBridge.OnTotalFriendCountUpdated += value;
 42378            remove => fallbackApiBridge.OnTotalFriendCountUpdated -= value;
 79        }
 80
 81        public event Action<FriendRequestPayload> OnFriendRequestReceived;
 82
 83        public static RPCFriendsApiBridge CreateSharedInstance(IRPC rpc, IFriendsApiBridge fallbackApiBridge)
 84        {
 42385            i = new RPCFriendsApiBridge(rpc, fallbackApiBridge);
 42386            return i;
 87        }
 88
 89        public static void RegisterService(RpcServerPort<RPCContext> port)
 90        {
 091            FriendRequestRendererServiceCodeGen.RegisterService(port, i);
 092        }
 93
 42394        public RPCFriendsApiBridge(IRPC rpc, IFriendsApiBridge fallbackApiBridge)
 95        {
 42396            this.rpc = rpc;
 42397            this.fallbackApiBridge = fallbackApiBridge;
 42398        }
 99
 100        public async UniTask<RejectFriendshipPayload> RejectFriendshipAsync(string friendRequestId, CancellationToken ca
 101        {
 102            try
 103            {
 0104                cancellationToken.ThrowIfCancellationRequested();
 105
 106                // TODO: pass cancellation token to rpc client when is supported
 0107                KernelRejectFriendRequestReply response = await rpc.FriendRequests()
 108                                                                   .RejectFriendRequest(new KernelRejectFriendRequestPay
 109                                                                    {
 110                                                                        FriendRequestId = friendRequestId
 111                                                                    }).Timeout(TimeSpan.FromSeconds(REQUEST_TIMEOUT));
 112
 0113                cancellationToken.ThrowIfCancellationRequested();
 114
 0115                RejectFriendshipPayload payload = response.MessageCase == KernelRejectFriendRequestReply.MessageOneofCas
 116                    ? new RejectFriendshipPayload
 117                    {
 118                        FriendRequestPayload = ToFriendRequestPayload(response.Reply.FriendRequest),
 119                    }
 120                    : throw new FriendshipException(ToErrorCode(response.Error));
 121
 0122                await UniTask.SwitchToMainThread(cancellationToken);
 123
 0124                return payload;
 125            }
 126            finally
 127            {
 0128                await UniTask.SwitchToMainThread();
 129            }
 0130        }
 131
 132        public void RemoveFriend(string userId) =>
 0133            fallbackApiBridge.RemoveFriend(userId);
 134
 135        public UniTask<AddFriendsPayload> GetFriendsAsync(int limit, int skip, CancellationToken cancellationToken = def
 0136            fallbackApiBridge.GetFriendsAsync(limit, skip, cancellationToken);
 137
 138        public UniTask<AddFriendsPayload> GetFriendsAsync(string usernameOrId, int limit, CancellationToken cancellation
 0139            fallbackApiBridge.GetFriendsAsync(usernameOrId, limit, cancellationToken);
 140
 141        public async UniTask<AddFriendRequestsV2Payload> GetFriendRequestsAsync(int sentLimit, int sentSkip,
 142            int receivedLimit, int receivedSkip,
 143            CancellationToken cancellationToken)
 144        {
 145            try
 146            {
 0147                cancellationToken.ThrowIfCancellationRequested();
 148
 149                // TODO: pass cancellation token to rpc client when is supported
 0150                GetFriendRequestsReply response = await rpc.FriendRequests()
 151                                                           .GetFriendRequests(new KernelGetFriendRequestsPayload
 152                                                            {
 153                                                                SentLimit = sentLimit,
 154                                                                SentSkip = sentSkip,
 155                                                                ReceivedLimit = receivedLimit,
 156                                                                ReceivedSkip = receivedSkip
 157                                                            })
 158                                                           .Timeout(TimeSpan.FromSeconds(REQUEST_TIMEOUT));
 159
 0160                cancellationToken.ThrowIfCancellationRequested();
 161
 0162                AddFriendRequestsV2Payload payload = response.MessageCase == GetFriendRequestsReply.MessageOneofCase.Err
 163                    ? throw new FriendshipException(ToErrorCode(response.Error))
 164                    : new AddFriendRequestsV2Payload
 165                    {
 166                        requestedTo = response.Reply.RequestedTo.Select(ToFriendRequestPayload).ToArray(),
 167                        requestedFrom = response.Reply.RequestedFrom.Select(ToFriendRequestPayload).ToArray(),
 168                        totalReceivedFriendRequests = response.Reply.TotalReceivedFriendRequests,
 169                        totalSentFriendRequests = response.Reply.TotalSentFriendRequests,
 170                    };
 171
 0172                await UniTask.SwitchToMainThread(cancellationToken);
 173
 0174                return payload;
 175            }
 176            finally
 177            {
 0178                await UniTask.SwitchToMainThread();
 179            }
 0180        }
 181
 182        public void GetFriendsWithDirectMessages(string usernameOrId, int limit, int skip) =>
 0183            fallbackApiBridge.GetFriendsWithDirectMessages(usernameOrId, limit, skip);
 184
 185        public async UniTask<RequestFriendshipConfirmationPayload> RequestFriendshipAsync(string userId, string messageB
 186            CancellationToken cancellationToken)
 187        {
 188            try
 189            {
 0190                cancellationToken.ThrowIfCancellationRequested();
 191
 192                // TODO: pass cancellation token to rpc client when is supported
 0193                SendFriendRequestReply reply = await rpc.FriendRequests()
 194                                                        .SendFriendRequest(new SendFriendRequestPayload
 195                                                         {
 196                                                             MessageBody = messageBody,
 197                                                             UserId = userId,
 198                                                         })
 199                                                        .Timeout(TimeSpan.FromSeconds(REQUEST_TIMEOUT));
 200
 0201                cancellationToken.ThrowIfCancellationRequested();
 202
 0203                RequestFriendshipConfirmationPayload payload = reply.MessageCase == SendFriendRequestReply.MessageOneofC
 204                    ? new RequestFriendshipConfirmationPayload
 205                    {
 206                        friendRequest = ToFriendRequestPayload(reply.Reply.FriendRequest),
 207                    }
 208                    : throw new FriendshipException(ToErrorCode(reply.Error));
 209
 0210                await UniTask.SwitchToMainThread(cancellationToken);
 211
 0212                return payload;
 213            }
 214            finally
 215            {
 0216                await UniTask.SwitchToMainThread();
 217            }
 0218        }
 219
 220        public async UniTask<CancelFriendshipConfirmationPayload> CancelRequestAsync(string friendRequestId,
 221            CancellationToken cancellationToken)
 222        {
 223            try
 224            {
 0225                cancellationToken.ThrowIfCancellationRequested();
 226
 227                // TODO: pass cancellation token to rpc client when is supported
 0228                KernelCancelFriendRequestReply reply = await rpc.FriendRequests()
 229                                                                .CancelFriendRequest(new KernelCancelFriendRequestPayloa
 230                                                                 {
 231                                                                     FriendRequestId = friendRequestId
 232                                                                 }).Timeout(TimeSpan.FromSeconds(REQUEST_TIMEOUT));
 233
 0234                cancellationToken.ThrowIfCancellationRequested();
 235
 0236                CancelFriendshipConfirmationPayload payload = reply.MessageCase == KernelCancelFriendRequestReply.Messag
 237                    ? new CancelFriendshipConfirmationPayload
 238                    {
 239                        friendRequest = ToFriendRequestPayload(reply.Reply.FriendRequest),
 240                    }
 241                    : throw new FriendshipException(ToErrorCode(reply.Error));
 242
 0243                await UniTask.SwitchToMainThread(cancellationToken);
 244
 0245                return payload;
 246            }
 247            finally
 248            {
 0249                await UniTask.SwitchToMainThread(cancellationToken);
 250            }
 0251        }
 252
 253        public UniTask<ApproveFriendRequestReply> ApproveFriendRequest(ApproveFriendRequestPayload request, RPCContext c
 254        {
 0255            OnFriendshipStatusUpdated?.InvokeOnMainThread(new FriendshipUpdateStatusMessage
 256            {
 257                action = FriendshipAction.APPROVED,
 258                userId = request.UserId
 259            });
 260
 0261            return UniTask.FromResult(new ApproveFriendRequestReply());
 262        }
 263
 264        public UniTask<RendererRejectFriendRequestReply> RejectFriendRequest(RendererRejectFriendRequestPayload request,
 265        {
 0266            OnFriendshipStatusUpdated?.InvokeOnMainThread(new FriendshipUpdateStatusMessage
 267            {
 268                action = FriendshipAction.REJECTED,
 269                userId = request.UserId
 270            });
 271
 0272            return UniTask.FromResult(new RendererRejectFriendRequestReply());
 273        }
 274
 275        public async UniTask<RendererCancelFriendRequestReply> CancelFriendRequest(RendererCancelFriendRequestPayload re
 276        {
 0277            await UniTask.SwitchToMainThread(ct);
 278
 0279            OnFriendshipStatusUpdated?.Invoke(new FriendshipUpdateStatusMessage
 280            {
 281                action = FriendshipAction.CANCELLED,
 282                userId = request.UserId
 283            });
 284
 0285            return new RendererCancelFriendRequestReply();
 0286        }
 287
 288        public async UniTask<ReceiveFriendRequestReply> ReceiveFriendRequest(ReceiveFriendRequestPayload request, RPCCon
 289        {
 0290            await UniTask.SwitchToMainThread(ct);
 291
 0292            OnFriendRequestReceived?.Invoke(ToFriendRequestPayload(request.FriendRequest));
 293
 0294            OnFriendshipStatusUpdated?.Invoke(new FriendshipUpdateStatusMessage
 295            {
 296                action = FriendshipAction.REQUESTED_FROM,
 297                userId = request.FriendRequest.From
 298            });
 299
 0300            return new ReceiveFriendRequestReply();
 0301        }
 302
 303        public async UniTask<AcceptFriendshipPayload> AcceptFriendshipAsync(string friendRequestId, CancellationToken ca
 304        {
 305            try
 306            {
 0307                cancellationToken.ThrowIfCancellationRequested();
 308
 309                // TODO: pass cancellation token to rpc client when is supported
 0310                AcceptFriendRequestReply response = await rpc.FriendRequests()
 311                                                             .AcceptFriendRequest(new AcceptFriendRequestPayload
 312                                                              {
 313                                                                  FriendRequestId = friendRequestId
 314                                                              }).Timeout(TimeSpan.FromSeconds(REQUEST_TIMEOUT));
 315
 0316                cancellationToken.ThrowIfCancellationRequested();
 317
 0318                AcceptFriendshipPayload payload = response.MessageCase == AcceptFriendRequestReply.MessageOneofCase.Repl
 319                    ? new AcceptFriendshipPayload
 320                    {
 321                        FriendRequest = ToFriendRequestPayload(response.Reply.FriendRequest)
 322                    }
 323                    : throw new FriendshipException(ToErrorCode(response.Error));
 324
 0325                await UniTask.SwitchToMainThread(cancellationToken);
 326
 0327                return payload;
 328            }
 329            finally
 330            {
 0331                await UniTask.SwitchToMainThread();
 332            }
 0333        }
 334
 335        public async UniTask<FriendshipStatus> GetFriendshipStatus(string userId, CancellationToken cancellationToken)
 336        {
 337            try
 338            {
 0339                cancellationToken.ThrowIfCancellationRequested();
 340
 341                // TODO: pass cancellation token to rpc client when is supported
 0342                GetFriendshipStatusResponse response = await rpc.Friends()
 343                                                                .GetFriendshipStatus(new GetFriendshipStatusRequest
 344                                                                 {
 345                                                                     UserId = userId
 346                                                                 }).Timeout(TimeSpan.FromSeconds(REQUEST_TIMEOUT));
 347
 0348                cancellationToken.ThrowIfCancellationRequested();
 349
 0350                FriendshipStatus status = ToFriendshipStatus(response.Status);
 351
 0352                await UniTask.SwitchToMainThread(cancellationToken);
 353
 0354                return status;
 355            }
 356            finally
 357            {
 0358                await UniTask.SwitchToMainThread();
 359            }
 0360        }
 361
 362        private FriendshipStatus ToFriendshipStatus(RPCFriendshipStatus status)
 363        {
 364            switch (status)
 365            {
 366                case RPCFriendshipStatus.Approved:
 0367                    return FriendshipStatus.FRIEND;
 368                case RPCFriendshipStatus.None:
 369                default:
 0370                    return FriendshipStatus.NOT_FRIEND;
 371                case RPCFriendshipStatus.RequestedFrom:
 0372                    return FriendshipStatus.REQUESTED_FROM;
 373                case RPCFriendshipStatus.RequestedTo:
 0374                    return FriendshipStatus.REQUESTED_TO;
 375            }
 376        }
 377
 378        private static FriendRequestPayload ToFriendRequestPayload(FriendRequestInfo request) =>
 0379            new()
 380            {
 381                from = request.From,
 382                timestamp = (long)request.Timestamp,
 383                to = request.To,
 384                messageBody = request.MessageBody,
 385                friendRequestId = request.FriendRequestId
 386            };
 387
 388        private FriendRequestErrorCodes ToErrorCode(FriendshipErrorCode code)
 389        {
 390            switch (code)
 391            {
 392                default:
 393                case FriendshipErrorCode.FecUnknown:
 0394                    return FriendRequestErrorCodes.Unknown;
 395                case FriendshipErrorCode.FecBlockedUser:
 0396                    return FriendRequestErrorCodes.BlockedUser;
 397                case FriendshipErrorCode.FecInvalidRequest:
 0398                    return FriendRequestErrorCodes.InvalidRequest;
 399                case FriendshipErrorCode.FecNonExistingUser:
 0400                    return FriendRequestErrorCodes.NonExistingUser;
 401                case FriendshipErrorCode.FecNotEnoughTimePassed:
 0402                    return FriendRequestErrorCodes.NotEnoughTimePassed;
 403                case FriendshipErrorCode.FecTooManyRequestsSent:
 0404                    return FriendRequestErrorCodes.TooManyRequestsSent;
 405            }
 406        }
 407    }
 408}
Generated by: ReportGenerator 5.0.4.0
01/24/2025 - 17:51:01
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)
RejectFriendshipAsync()
RemoveFriend(System.String)
GetFriendsAsync(System.Int32, System.Int32, System.Threading.CancellationToken)
GetFriendsAsync(System.String, System.Int32, System.Threading.CancellationToken)
GetFriendRequestsAsync()
GetFriendsWithDirectMessages(System.String, System.Int32, System.Int32)
RequestFriendshipAsync()
CancelRequestAsync()
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)