public SubscriptionCommands(
            Contacts contacts,
            XmppClientEx xmppClient,
            MyViewModel viewModel,
            SubscriptionRequests subscriptionRequests)
        {
            this.contacts             = contacts;
            this.xmppClient           = xmppClient;
            this.viewModel            = viewModel;
            this.SubscriptionRequests = subscriptionRequests;

            ApproveSubscriptionRequest = ReactiveCommand.Create <SubscriptionRequest>(
                async sr =>
            {
                await xmppClient.ApproveSubscriptionRequestAsync(sr.Jid);
                if (!contacts.Contains(sr.Jid))
                {
                    // we approved a contact which is not on our contact list
                    // => add it now
                    await xmppClient.AddRosterItemAsync(sr.Jid, sr.Name);
                    await xmppClient.SubscribeAsync(sr.Jid);
                }
                else
                {
                    // handle from and none
                    var contact = contacts[sr.Jid];
                    if (contact.Subscription == Subscription.From ||
                        contact.Subscription == Subscription.None)
                    {
                        await xmppClient.SubscribeAsync(sr.Jid);
                    }
                }
                this.SubscriptionRequests.Remove(sr);
            }
                , this.viewModel.IsConnectedObervalble
                );

            DenySubscriptionRequest = ReactiveCommand.Create <SubscriptionRequest>(
                async sr =>
            {
                await xmppClient.DenySubscriptionRequestAsync(sr.Jid);
                SubscriptionRequests.Remove(sr);
            }
                , this.viewModel.IsConnectedObervalble
                );
        }
Exemplo n.º 2
0
        public RosterCommands(
            XmppClientEx xmppClient,
            MyViewModel viewModel,
            AddUser addUser)
        {
            this.xmppClient = xmppClient;
            this.viewModel  = viewModel;
            this.addUser    = addUser;

            RegexUtilities regexUtils = new RegexUtilities();

            var canAddUser = this
                             .WhenAnyValue(x => x.addUser.XmppId, x => x.viewModel.IsConnected,
                                           (xmppId, isConnected) =>
                                           !String.IsNullOrWhiteSpace(xmppId) &&
                                           regexUtils.IsValidXmppId(xmppId) &&
                                           isConnected)
                             .DistinctUntilChanged();

            RemoveContact = ReactiveCommand.Create <Contact>(
                async contact =>
            {
                await this.xmppClient.RemoveRosterItemAsync(new Matrix.Jid(contact.Jid));
                await this.xmppClient.CancelSubscriptionAsync(contact.Jid);
                await this.xmppClient.UnsubscribeAsync(contact.Jid);
            }
                , this.viewModel.IsConnectedObervalble
                );

            AddContact = ReactiveCommand.Create <AddUser>(
                async user =>
            {
                await xmppClient.AddRosterItemAsync(user.XmppId, user.Name);
                await xmppClient.SubscribeAsync(user.XmppId, user.Message);

                this.addUser.Reset();
            }
                , canAddUser
                );
        }