public static string GetPresenceDisplay(Presence presence) { if (presence.Type == PresenceType.available) { if (!String.IsNullOrEmpty(presence.Show)) { switch (presence.Show) { case "away": return "away"; case "chat": return "free to chat"; case "dnd": return "do not disturb"; case "xa": return "extended away"; case "subscribed": return "subscribed"; default: return presence.Show; } } else { return "available"; } } else if (presence.Type == PresenceType.unavailable) { return "offline"; } else { throw new ArgumentException("presence type not supported: " + presence.Type); } }
public void Test_Create() { Presence p = new Presence(doc); p.Type = PresenceType.available; p.Status = "foo"; Assert.AreEqual("<presence><status>foo</status></presence>", p.ToString()); }
static void Main(string[] args) { var presence = new Presence("clusters/commerce", new Dictionary<string, string> { {"RavenDB-Url", new UriBuilder("http", Environment.MachineName, 8080).Uri.ToString()} }, TimeSpan.FromSeconds(3)); presence.TopologyChanged += (sender, nodeMetadata) => { switch (nodeMetadata.ChangeType) { case TopologyChangeType.MasterSelected: Console.WriteLine("Master selected {0}", nodeMetadata.Uri); break; case TopologyChangeType.Discovered: Console.WriteLine("Found {0}", nodeMetadata.Uri); break; case TopologyChangeType.Gone: Console.WriteLine("Oh no, {0} is gone!", nodeMetadata.Uri); break; default: throw new ArgumentOutOfRangeException(); } }; presence.Start(); Console.WriteLine(presence.Address); Console.WriteLine("Waiting..."); Console.ReadLine(); }
public Acceptor(Presence presence, Uri originatorUri, Uri[] learners) : base(presence) { this.originatorUri = originatorUri; this.learners = learners; Register<Propose>(OnPropose); Register<Accept>(OnAccept); }
static ContactsNotificationService() { ContactsNotificationService.OfflinePresence = new Presence() { PresenceType = PresenceType.Offline }; ContactsNotificationService.Contacts = new ConcurrentDictionary<string, ContactsNotificationService.JsFederatedDude>(); }
public void TestUserHost() { PresenceManager pp = new PresenceManager(); Presence pres = new Presence(doc); JID f = new JID("foo", "bar", null); pres.From = f; pp.AddPresence(pres); Assert.AreEqual("foo@bar", pp[f.Bare].From.ToString()); }
public Pet(StatsDK dkstats, DeathKnightTalents t, BossOptions bo, Presence p) { m_BO = bo; m_DKStats = dkstats; m_Talents = t; m_Presence = p; AccumulateStats(); }
public static string GetResourceDisplay(Presence presence) { if (presence["ResourceDisplay"] != null && !String.IsNullOrEmpty(presence["ResourceDisplay"].InnerText)) return presence["ResourceDisplay"].InnerText; else if (!String.IsNullOrEmpty(presence.From.Resource)) return presence.From.Resource; else return "Unknown"; }
internal InputArg(InputArgType type, string name, object defaultValue, Presence presence, string helpString) { HasBeenSeen = false; Type = type; Name = name; Value = defaultValue; Presence = presence; HelpString = helpString; HasBeenSeen = false; }
public void Test_Available() { Presence p = new Presence(doc); Assert.AreEqual(PresenceType.available, p.Type); Assert.AreEqual("", p.GetAttribute("type")); p.Type = PresenceType.unavailable; Assert.AreEqual(PresenceType.unavailable, p.Type); Assert.AreEqual("unavailable", p.GetAttribute("type")); p.Type = PresenceType.available; Assert.AreEqual(PresenceType.available, p.Type); Assert.AreEqual("", p.GetAttribute("type")); }
public Proposer(Presence presence, Acceptor myAcceptor, Uri orignatorUri, Uri[] allAcceptors) : base(presence) { this.myAcceptor = myAcceptor; this.orignatorUri = orignatorUri; this.allAcceptors = allAcceptors; ballotBase = base.GetHashCode()%25; // effectively a random choice Register<Promise>(OnPromise); Register<ProposalSubsumed>(OnProposalSubsumed); Register<Accepted>(OnAccepted); }
public Encoding() { _primitiveType = null; _presence = Presence.Required; _byteOrder = ByteOrder.LittleEndian; _minValue = null; _maxValue = null; _nullValue = null; _constValue = null; _characterEncoding = null; _epoch = null; _timeUnit = null; _semanticType = null; }
public Encoding(PrimitiveType primitiveType, Presence presence, ByteOrder byteOrder, PrimitiveValue minValue, PrimitiveValue maxValue, PrimitiveValue nullValue, PrimitiveValue constValue, string characterEncoding, string epoch, string timeUnit, string semanticType) { Verify.NotNull(presence, "presence"); Verify.NotNull(byteOrder, "byteOrder"); _primitiveType = primitiveType; _presence = presence; _byteOrder = byteOrder; _minValue = minValue; _maxValue = maxValue; _nullValue = nullValue; _constValue = constValue; _characterEncoding = characterEncoding; _epoch = epoch; _timeUnit = timeUnit; _semanticType = semanticType; }
public void TestAdd() { PresenceManager pp = new PresenceManager(); Presence pres = new Presence(doc); JID f = new JID("foo", "bar", "baz"); pres.From = f; pp.AddPresence(pres); Assert.AreEqual("foo@bar/baz", pp[f].From.ToString()); f.Resource = null; Assert.AreEqual("foo@bar/baz", pp[f].From.ToString()); pres = new Presence(doc); pres.Status = "wandering"; pres.From = new JID("foo", "bar", "baz"); pp.AddPresence(pres); Assert.AreEqual("wandering", pp[f].Status); }
/// <summary> /// Определение статуса юзера. /// </summary> /// <param name="pres"></param> public void SetOnlineStateFromPresence(Presence pres) { if (pres.Type == Matrix.Xmpp.PresenceType.unavailable) StatusOnline = Model.StatusOnline.Offline; if (pres.Type == Matrix.Xmpp.PresenceType.available) { if (pres.Show == Matrix.Xmpp.Show.chat) StatusOnline = Model.StatusOnline.Chat; else if (pres.Show == Matrix.Xmpp.Show.away) StatusOnline = Model.StatusOnline.Away; else if (pres.Show == Matrix.Xmpp.Show.xa) StatusOnline = Model.StatusOnline.ExtendedAway; else if (pres.Show == Matrix.Xmpp.Show.dnd) StatusOnline = Model.StatusOnline.DoNotDisturb; else if (pres.Show == Matrix.Xmpp.Show.NONE) StatusOnline = Model.StatusOnline.Online; else StatusOnline = Model.StatusOnline.Online; } //определяем в зависимости от статуса, какую иконку статуса отображать switch (StatusOnline) { case StatusOnline.Online: ImageStatus = @"ContactListSettings/StatusImage/online.png"; break; case StatusOnline.Offline: ImageStatus = @"ContactListSettings/StatusImage/offline.png"; break; case StatusOnline.Away: ImageStatus = @"ContactListSettings/StatusImage/away.png"; break; case StatusOnline.ExtendedAway: ImageStatus = @"ContactListSettings/StatusImage/extendedAway.png"; break; case StatusOnline.DoNotDisturb: ImageStatus = @"ContactListSettings/StatusImage/doNotDisturb.png"; break; case StatusOnline.Chat: ImageStatus = @"ContactListSettings/StatusImage/chat.png"; break; } }
public static int GetRosterImageIndex(Presence pres) { if (pres.Type == PresenceType.Unavailable) return 0; switch (pres.Show) { case Show.Chat: return 1; case Show.Away: return 2; case Show.ExtendedAway: return 2; case Show.DoNotDisturb: return 3; default: return 1; } }
public static int GetRosterImageIndex(Presence pres) { if (pres.Type == PresenceType.unavailable) return 0; switch (pres.Show) { case Show.chat: return 1; case Show.away: return 2; case Show.xa: return 2; case Show.dnd: return 3; default: return 1; } }
public void TestRetrieve() { PresenceManager pp = new PresenceManager(); Presence pres = new Presence(doc); JID f = new JID("foo", "bar", "baz"); pres.From = f; pres.Priority = "0"; pp.AddPresence(pres); Assert.AreEqual("foo@bar/baz", pp[f.Bare].From.ToString()); pres = new Presence(doc); f = new JID("foo", "bar", "bay"); pres.From = f; pres.Priority = "1"; pp.AddPresence(pres); Assert.AreEqual("foo@bar/bay", pp[f.Bare].From.ToString()); pres = new Presence(doc); pres.From = f; pres.Type = PresenceType.unavailable; pp.AddPresence(pres); Assert.AreEqual("foo@bar/baz", pp[f.Bare].From.ToString()); }
public void Test_Order() { Presence small = new Presence(doc); DateTime d = DateTime.Now; small.IntPriority = 0; small.Stamp = d; Presence big = new Presence(doc); big.IntPriority = 10; big.Stamp = d.AddSeconds(1); Assert.IsTrue(small < big); Assert.IsTrue(big > small); small.IntPriority = 10; small.Show = "dnd"; Assert.IsTrue(small < big); big.Show = "chat"; Assert.IsTrue(small < big); small.Show = "chat"; Assert.IsTrue(small < big); }
public static int GetRosterImageIndex(Presence pres) { if ((pres.get_Type() != 4) && (pres.get_Type() != 6)) { switch (pres.get_Show()) { case -1: return 1; case 0: return 2; case 1: return 4; case 2: return 5; case 3: return 3; } } return 0; }
private void rm_OnUnsubscription(jabber.client.RosterManager manager, Presence pres, ref bool remove) { MessageBox.Show(pres.From + " has removed you from their roster.", "Unsubscription notification", MessageBoxButtons.OK); }
private void rm_OnSubscription(jabber.client.RosterManager manager, Item ri, Presence pres) { DialogResult res = MessageBox.Show("Allow incoming presence subscription request from: " + pres.From, "Subscription Request", MessageBoxButtons.YesNoCancel); switch (res) { case DialogResult.Yes: manager.ReplyAllow(pres); break; case DialogResult.No: manager.ReplyDeny(pres); break; case DialogResult.Cancel: // do nothing; break; } }
private void muc_OnPresenceError(Room room, Presence pres) { m_err = true; pnlCon.Text = "Groupchat error: " + pres.Error.OuterXml; }
/// <summary> /// Denies the subscription request. /// </summary> /// <param name="pres"> /// The presence packet containing the subscription request. /// </param> public void ReplyDeny(Presence pres) { Debug.Assert(pres.Type == PresenceType.subscribe); Presence reply = new Presence(m_stream.Document); reply.To = pres.From; reply.Type = PresenceType.unsubscribed; m_stream.Write(reply); }
/// <summary> /// Allows the subscription request and sends a subscribed to the user. /// </summary> /// <param name="pres"> /// The presence packet containing the subscription request. /// </param> public void ReplyAllow(Presence pres) { Debug.Assert(pres.Type == PresenceType.subscribe); Presence reply = new Presence(m_stream.Document); reply.To = pres.From; reply.Type = PresenceType.subscribed; m_stream.Write(reply); if (m_autoSubscribe) { Presence sub = new Presence(m_stream.Document); sub.To = pres.From; sub.Type = PresenceType.subscribe; m_stream.Write(sub); } }
// Retrieve the friend's connected S2 node address. Returns null if not found public string searchForRelay() { string ip = null; byte[] wallet = null; Presence presence = PresenceList.containsWalletAddress(walletAddress); if (presence == null) { return(ip); } lock (PresenceList.presences) { // Go through each presence address searching for C nodes foreach (PresenceAddress addr in presence.addresses) { // Only check Client nodes if (addr.type == 'C') { // We have a potential candidate here, store it string candidate_ip = addr.address; // Go through each presence again. This should be more optimized. foreach (Presence s2presence in PresenceList.presences) { // Go through each single address foreach (PresenceAddress s2addr in s2presence.addresses) { // Only check Relay nodes that have the candidate ip if (s2addr.type == 'R' && s2addr.address.Equals(candidate_ip, StringComparison.Ordinal)) { // We found the friend's connected s2 node ip = s2addr.address; wallet = s2presence.wallet; break; } } } } else // Check for R nodes for testing purposes if (addr.type == 'R') { ip = addr.address; wallet = presence.wallet; } // If we find a valid node ip, don't continue searching if (ip != null) { break; } } } // Store the last relay ip and wallet for this friend relayIP = ip; relayWallet = wallet; // Finally, return the ip address of the node return(relayIP); }
/// <summary> /// Sends a presence subscription request and updates the roster /// for a new roster contact. /// </summary> /// <param name="to">The JID of the contact (required)</param> /// <param name="nickname">The nickname to show for the contact.</param> /// <param name="groups">A list of groups to put the contact in. May be null. Hint: new string[] {"foo", "bar"}</param> public void Subscribe(JID to, string nickname, string[] groups) { Debug.Assert(to != null); RosterIQ riq = new RosterIQ(Document) {Type = IQType.Set}; Roster r = riq.Instruction; Item i = r.AddItem(); i.JID = to; if (nickname != null) i.Nickname = nickname; if (groups != null) { foreach (string g in groups) i.AddGroup(g); } Write(riq); // don't care about result. we should get a iq/response and a roster push. Presence pres = new Presence(Document) {To = to, Type = PresenceType.subscribe}; Write(pres); }
public HandleUpdate(Presence presence) => Presence = presence;
public void EmitPresence(Action <PresenceResponse> callback, Presence status) { APIRequestWithToken(callback, new Tuple <string, string>("presence", status.ToString())); }
private void rm_OnSubscription(RosterManager manager, Item ri, Presence pres) { manager.ReplyAllow(pres); OnMessage("WMSMLC", string.Format("Пользовтель {0} добавился в список контактов", pres.From)); }
private void rm_OnUnsubscription(RosterManager manager, Presence pres, ref bool remove) { OnMessage("WMSMLC", string.Format("Пользовтель {0} удалился из списока контактов", pres.From)); }
/// <summary> /// Closes down the connection. /// </summary> public override void Close() { if (IsAuthenticated) { Presence p = new Presence(Document) {Type = PresenceType.unavailable, Status = "offline"}; Write(p); } base.Close(); }
/// <summary> /// Sends a presence packet to the XMPP server. /// </summary> /// <param name="t">The type of presence.</param> /// <param name="status">Determines the status of the presence.</param> /// <param name="show">Shows the available, away, dnd and so on status.</param> /// <param name="priority">Prioritizes this connection. /// Higher number mean higher priority. 0 minumum, 127 max. /// -1 means this is a presence-only connection.</param> public void Presence(PresenceType t, string status, string show, int priority) { if (IsAuthenticated) { if ((priority < -128) || (priority > 127)) { throw new ArgumentException("Priority must be -128 to 127", "priority"); } Presence p = new Presence(Document); if (status != null) p.Status = status; if (t != PresenceType.available) { p.Type = t; } if (show != null) p.Show = show; p.Priority = priority.ToString(); if (OnBeforePresenceOut != null) OnBeforePresenceOut(this, p); Write(p); if (OnAfterPresenceOut != null) OnAfterPresenceOut(this, p); } else { throw new InvalidOperationException("Client must be authenticated before sending presence."); } }
/// <summary> /// Exits the room. This cleans up the entry in the ConferenceManager, as well. /// </summary> /// <param name="reason">Reason for leaving the room. May be null for no reason.</param> public void Leave(string reason) { m_state = STATE.leaving; /* <presence to='[email protected]/oldhag' type='unavailable'> <status>gone where the goblins go</status> </presence> */ Presence p = new Presence(m_manager.Stream.Document); p.To = m_jid; p.Type = PresenceType.unavailable; if (reason != null) p.Status = reason; m_manager.Write(p); // cleanup done when unavailable/110 received. }
public XmppWebSocketConnection(JID jid, string password, string websocketUri) : base(jid, password) { Capabilities = new CapabilitiesManager { Identity = new Identity { Category = "client", IdentityType = "mobile", IdentityName = "SharpXMPP" }, Node = "http://bggg.net.ru/caps", Features = new List <string> { Namespaces.DiscoInfo, Namespaces.DiscoItems } }; IqTracker = new XMPP.Client.IqHandler(this) { ResponseHandlers = new Dictionary <string, ResponseHandler>(), PayloadHandlers = new List <PayloadHandler> { new InfoHandler(Capabilities), new ItemsHandler() } }; Iq += (sender, iq) => IqTracker.Handle(iq); // ReSharper disable RedundantArgumentDefaultValue _connection = new WebSocket(websocketUri, "xmpp", cookies: (List <KeyValuePair <string, string> >)null); // ReSharper restore RedundantArgumentDefaultValue _connection.Opened += (sender, args) => { _currentState = XmppConnectionState.Connected; RestartStream(); }; _connection.MessageReceived += (sender, args) => { if (_currentState == XmppConnectionState.Connected) { ReadStreamStart(args.Message); _currentState = XmppConnectionState.StreamInitiated; } else if (_currentState == XmppConnectionState.StreamAuthenticated) { ReadStreamStart(args.Message); _currentState = XmppConnectionState.StreamResourceBindingRequest; } else { var currentStanza = Stanza.Parse(args.Message); OnElement(new ElementArgs { IsInput = false, Stanza = currentStanza }); var error = Stanza.Parse <StreamError>(currentStanza); if (error != null) { OnConnectionFailed(new ConnFailedArgs { Message = error.Value }); return; } switch (_currentState) { case XmppConnectionState.StreamInitiated: var features = Stanza.Parse <Features>(currentStanza); authenticator = SASLHandler.Create(features.SaslMechanisms, Jid, Password); if (authenticator == null) { OnConnectionFailed(new ConnFailedArgs { Message = "supported sasl mechanism not available" }); return; } var auth = new SASLAuth(); auth.SetAttributeValue("mechanism", authenticator.SASLMethod); var authInit = authenticator.Initiate(); if (!string.IsNullOrEmpty(authInit)) { auth.SetValue(authInit); } Send(auth); _currentState = XmppConnectionState.StreamAuthenticating; break; case XmppConnectionState.StreamAuthenticating: switch (currentStanza.Name.LocalName) { case "success": _currentState = XmppConnectionState.StreamAuthenticated; RestartStream(); break; case "failure": OnConnectionFailed(new ConnFailedArgs { Message = currentStanza.Value }); _currentState = XmppConnectionState.Disconnected; return; case "challenge": var response = new SASLResponse(); response.SetValue( authenticator.NextChallenge(currentStanza.Value)); Send(response); break; } break; case XmppConnectionState.StreamResourceBindingRequest: // todo: parse features of negotiated stream //Stanza.Parse<Features>(currentStanza); var bind = new Bind(Jid.Resource); var iq = new Iq(XMPP.Client.Elements.Iq.IqTypes.set); iq.Add(bind); Send(iq); _currentState = XmppConnectionState.StreamResourceBindingResponse; break; case XmppConnectionState.StreamResourceBindingResponse: var bindedJid = currentStanza.Element( XNamespace.Get(Namespaces.XmppBind) + "bind"); if (bindedJid == null) { OnConnectionFailed(new ConnFailedArgs { Message = "bind failed" }); _currentState = XmppConnectionState.Disconnected; } else { var sess = new XElement( XNamespace.Get(Namespaces.XmppSession) + "session"); var sessIq = new Iq(XMPP.Client.Elements.Iq.IqTypes.set); sessIq.Add(sess); Send(sessIq); _currentState = XmppConnectionState.StreamSessionNoOp; Jid = new JID( bindedJid.Element( XNamespace.Get(Namespaces.XmppBind) + "jid") .Value); } break; case XmppConnectionState.StreamSessionNoOp: OnSignedIn(new SignedInArgs { Jid = Jid }); Roster.Query(this); var initPresence = new Presence(Capabilities); Send(initPresence); _currentState = XmppConnectionState.StreamNegotiated; break; case XmppConnectionState.StreamNegotiated: if (currentStanza.Name.LocalName.Equals("iq")) { OnIq(Stanza.Parse <Iq>(currentStanza)); } if (currentStanza.Name.LocalName.Equals("message")) { OnMessage(Stanza.Parse <Message>(currentStanza)); } break; default: throw new IOException("Invalid state"); } } }; }
private void cli_OnPresence(object sender, Presence pres) { PresenceType typ = pres.Type; switch (typ) { case PresenceType.available: case PresenceType.unavailable: case PresenceType.error: case PresenceType.probe: return; case PresenceType.subscribe: switch (m_autoAllow) { case AutoSubscriptionHanding.AllowAll: ReplyAllow(pres); return; case AutoSubscriptionHanding.DenyAll: ReplyDeny(pres); return; case AutoSubscriptionHanding.NONE: if (OnSubscription != null) OnSubscription(this, this[pres.From], pres); return; case AutoSubscriptionHanding.AllowIfSubscribed: Item ri = this[pres.From]; if (ri != null) { switch (ri.Subscription) { case Subscription.to: ReplyAllow(pres); return; case Subscription.from: case Subscription.both: // Almost an assert throw new InvalidOperationException("Server sent a presence subscribe for an already-subscribed contact"); case Subscription.none: if (ri.Ask == Ask.subscribe) { ReplyAllow(pres); return; } break; } } if (OnSubscription != null) OnSubscription(this, ri, pres); break; } break; case PresenceType.subscribed: // This is the new ack case. Presence sub_ack = new Presence(m_stream.Document); sub_ack.To = pres.From; sub_ack.Type = PresenceType.subscribe; m_stream.Write(sub_ack); break; case PresenceType.unsubscribe: // ack. we'll likely get an unsubscribed soon, anyway. Presence un_ack = new Presence(m_stream.Document); un_ack.To = pres.From; un_ack.Type = PresenceType.unsubscribed; m_stream.Write(un_ack); break; case PresenceType.unsubscribed: bool remove = true; if (OnUnsubscription != null) OnUnsubscription(this, pres, ref remove); if (remove) Remove(pres.From); break; } }