private async void _dataProvider_UserSubscriptionUpdated(object sender, UserSubscriptionUpdatedEventArgs args)
        {
            try {
                var subscriberUsername = args.Subscription.SubscriberUserId;
                var subscription       = args.Subscription;
                var userId             = args.Subscription.UserId;

                var userConnection = _server.ConnectionProvider
                                     .GetConnections(userId)
                                     .Where(con => con.State == ConnectionState.Connected)
                                     .FirstOrDefault();

                User user = null;

                if (userConnection != null)
                {
                    user = userConnection.User;
                }
                else
                {
                    user = new User(userId, null);
                }

                var subUpdatePacket = new RequestPacket(nameof(IServerCalls.UserSubscriptionUpdated))
                {
                    ["user"] = user,
                };
                UserSubscription.AddToPacket(subUpdatePacket, subscription);
                if (subscription.UpdateType == UpdateType.Add || subscription.UpdateType == UpdateType.Update)
                {
                    subUpdatePacket["userStatus"] = _dataProvider.GetUserStatus(userId);
                }

                try {
                    await _server.Request(subUpdatePacket, subscriberUsername);
                } catch (ErrorResponseException ex) {
                    Log.Warn(ex);
                } catch (Exception ex) {
                    Signal.Exception(ex);
                }
            } catch (Exception ex) {
                Signal.Exception(ex);
            }
        }
Пример #2
0
        public ClientSubscriptionModule(Client client)
        {
            RPC = new ClientCalls(client);

            RequestHandler requestHandler;

            Attach(requestHandler = new RequestHandler());

            requestHandler.Register(nameof(IServerCalls.UserStatusUpdated), (RequestPacket request) => {
                var userUpdateArgs = new UserUpdatedEventArgs {
                    Client     = request.Context.Client,
                    User       = (User)request["user"],
                    UserStatus = (string)request["userStatus"]
                };
                UserUpdated?.Invoke(this, userUpdateArgs);
                return(Task.FromResult(ProcessResult.Processed));
            });

            requestHandler.Register(nameof(IServerCalls.UserSubscriptionUpdated), async(RequestPacket request) => {
                var subscription = UserSubscription.GetFromPacket(request);

                var usubArgs = new UserSubscriptionUpdatedEventArgs {
                    Client       = request.Context.Client,
                    Subscription = subscription
                };
                UserSubscriptionUpdated?.Invoke(this, usubArgs);
                if (subscription.UpdateType == UpdateType.Add)
                {
                    var userUpdateArgs = new UserUpdatedEventArgs {
                        Client     = request.Context.Client,
                        User       = (User)request["user"],
                        UserStatus = (string)request["userStatus"]
                    };
                    UserUpdated?.Invoke(this, userUpdateArgs);
                }
                return(ProcessResult.Processed);
            });
        }