/// <summary>
        ///     Write an object to JSON.
        /// </summary>
        /// <param name="writer">
        ///     The <see cref="JsonWriter"/> to write to.
        /// </param>
        /// <param name="value">
        ///     The value to write.
        /// </param>
        /// <param name="serializer">
        ///     The current <see cref="JsonSerializer"/>.
        /// </param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (writer == null)
            {
                throw new ArgumentNullException(nameof(writer));
            }

            if (value is PrometheusValue prometheusValue)
            {
                writer.WriteStartArray();

                writer.WriteValue(
                    UnixDateTime.ToUnix(prometheusValue.Timestamp)
                    );

                if (prometheusValue.Value != null)
                {
                    writer.WriteValue(prometheusValue.Value);
                }
                else
                {
                    writer.WriteNull();
                }

                writer.WriteEndArray();
            }
            else if (value == null)
            {
                writer.WriteNull();
            }
            else
            {
                throw new JsonException("Expected PrometheusValue.");
            }
        }
Esempio n. 2
0
        public XmppHandlerResult ProcessElement(Presence element, XmppSession session, XmppHandlerContext context)
        {
            var result = Component();

            if (!element.HasTo)
            {
                // send to itself available resource
                foreach (var s in context.Sessions.GetSessions(element.From.BareJid).Where(s => s.Available))
                {
                    var p = (Presence)element.Clone();
                    p.To = s.Jid;
                    result.Add(Send(s, p));
                }

                var last = new Last {
                    Value = element.Status, Seconds = UnixDateTime.ToUnix(DateTime.UtcNow)
                };
                context.Storages.Elements.SaveElement(session.Jid, agsXMPP.Uri.IQ_LAST, last);

                // broadcast to subscribers
                foreach (var to in context.Storages.Users.GetSubscribers(session.Jid))
                {
                    foreach (var s in context.Sessions.GetSessions(to.BareJid).Where(s => s.Available))
                    {
                        var p = (Presence)element.Clone();
                        p.To = s.Jid;
                        result.Add(Send(s, p));
                    }
                }

                session.Presence = element;
            }
            return(result);
        }
        public XmppHandlerResult ProcessElement(LastIq element, XmppSession session, XmppHandlerContext context)
        {
            if (!element.HasTo)
            {
                return(Error(session, ErrorCondition.BadRequest, element));
            }

            if (element.Type == IqType.get)
            {
                var ri = context.Storages.Users.GetRosterItem(session.Jid, element.To);
                if (ri == null || !ri.HasToSubscription())
                {
                    return(Error(session, ErrorCondition.Forbidden, element));
                }
            }

            if (element.Type == IqType.get && element.To.IsBare)
            {
                if (context.Sessions.GetSessions(element.To).Any())
                {
                    element.Query.Seconds = 0;
                }
                else
                {
                    var last = context.Storages.Elements.GetElement(element.To, agsXMPP.Uri.IQ_LAST) as Last;
                    if (last != null)
                    {
                        element.Query.Seconds = UnixDateTime.ToUnix(DateTime.UtcNow) - last.Seconds;
                        element.Query.Value   = last.Value;
                    }
                    else
                    {
                        return(Error(session, ErrorCondition.ItemNotFound, element));
                    }
                }
                return(Send(session, element.ToResult()));
            }
            else if (element.To.IsFull)
            {
                var to = context.Sessions.GetSession(element.To);
                if (to == null)
                {
                    return(element.Type == IqType.get ? Error(session, ErrorCondition.RecipientUnavailable, element) : Void());
                }

                return(Request(to, element, Error(session, ErrorCondition.RecipientUnavailable, element)));
            }

            return(element.Type == IqType.get ? Error(session, ErrorCondition.ServiceUnavailable, element) : Void());
        }