internal static StatusMessage Parse(TokensBase t, JObject j)
{
return(new StatusMessage()
{
Status = j.ToObject <Status>()
});
}
internal static EventMessage Parse(TokensBase t, JObject j)
{
var e = new EventMessage();
e.Target = j["target"].ToObject <User>();
e.Source = j["source"].ToObject <User>();
e.Event = (EventCode)Enum.Parse(typeof(EventCode), ((string)j["event"]).Replace("_", ""), true);
e.CreatedAt = DateTimeOffset.ParseExact((string)j["created_at"], "ddd MMM dd HH:mm:ss K yyyy",
System.Globalization.DateTimeFormatInfo.InvariantInfo,
System.Globalization.DateTimeStyles.AllowWhiteSpaces);
var eventstr = (string)j["event"];
e.TargetType = eventstr.Contains("List") ? EventTargetType.List :
eventstr.Contains("favorite") ? EventTargetType.Status : EventTargetType.Null;
switch (e.TargetType)
{
case EventTargetType.Status:
e.TargetStatus = j["target_object"].ToObject <Status>();
break;
case EventTargetType.List:
e.TargetList = j["target_object"].ToObject <CoreTweet.List>();
break;
default:
break;
}
return(e);
}
internal static RawJsonMessage Create(TokensBase t, string json)
{
return(new RawJsonMessage
{
Json = json
});
}
internal static EnvelopesMessage Parse(TokensBase t, JObject j)
{
return(new EnvelopesMessage()
{
ForUser = (long)j["for_user"],
Message = StreamingMessage.Parse(t, j["message"].ToString(Formatting.None))
});
}
internal LineDelimitedJsonStreamResponseStreamer(
TokensBase tokens,
MethodType methodType, string url,
IEnumerable <KeyValuePair <string, object> > parameters)
{
_tokens = tokens;
_methodType = methodType;
_url = url;
_parameters = parameters;
}
/// <summary>
/// Extracts the root to parse
/// </summary>
static StreamingMessage ExtractRoot(TokensBase tokens, JObject jo)
{
JToken jt;
if (jo.TryGetValue("disconnect", out jt))
{
return(jt.ToObject <DisconnectMessage>());
}
else if (jo.TryGetValue("warning", out jt))
{
return(jt.ToObject <WarningMessage>());
}
else if (jo.TryGetValue("control", out jt))
{
return(jt.ToObject <ControlMessage>());
}
else if (jo.TryGetValue("delete", out jt))
{
var id = jt.ToObject <IDMessage>();
id.messageType = MessageType.Delete;
return(id);
}
else if (jo.TryGetValue("scrub_geo", out jt))
{
var id = jt.ToObject <IDMessage>();
id.messageType = MessageType.ScrubGeo;
return(id);
}
else if (jo.TryGetValue("limit", out jt))
{
return(jt.ToObject <LimitMessage>());
}
else if (jo.TryGetValue("status_withheld", out jt))
{
var id = jt.ToObject <IDMessage>();
id.messageType = MessageType.StatusWithheld;
return(id);
}
else if (jo.TryGetValue("user_withheld", out jt))
{
var id = jt.ToObject <IDMessage>();
id.messageType = MessageType.UserWithheld;
return(id);
}
else
{
throw new ParsingException("on streaming, cannot parse the json", jo.ToString(Formatting.Indented), null);
}
}
/// <summary>
/// Create a <see cref="CoreTweet.TwitterException"/> instance from the <see cref="System.Net.WebException"/>.
/// </summary>
/// <param name="tokens">OAuth tokens.</param>
/// <param name="ex">The thrown <see cref="System.Net.WebException"/>.</param>
/// <returns><see cref="CoreTweet.TwitterException"/> instance or null.</returns>
public static TwitterException Create(TokensBase tokens, WebException ex)
{
try
{
return(from x in new StreamReader(ex.Response.GetResponseStream()).Use()
select new TwitterException(
(ex.Response as HttpWebResponse).StatusCode,
JObject.Parse(x.ReadToEnd())["errors"]
.Select(e => e.ToObject <Error>())
.ToArray(),
ex
));
}
catch
{
return(null);
}
}
internal static IEnumerable <T> Enumerate(TokensBase tokens, string apiName, EnumerateMode mode, IDictionary <string, object> parameters)
{
var r = tokens.AccessApi <Cursored <T> >(MethodType.Get, apiName, parameters);
while (true)
{
foreach (var i in r)
{
yield return(i);
}
var next = mode == EnumerateMode.Next ? r.NextCursor : r.PreviousCursor;
if (next == 0)
{
break;
}
parameters["cursor"] = next;
r = tokens.AccessApi <Cursored <T> >(MethodType.Get, apiName, parameters);
}
}
internal static IEnumerable <T> EnumerateImpl(TokensBase tokens, string apiName, EnumerateMode mode, IEnumerable <KeyValuePair <string, object> > parameters)
{
var prmList = parameters.ToList();
var r = tokens.AccessApiImpl <Cursored <T> >(MethodType.Get, apiName, prmList, "");
while (true)
{
foreach (var i in r)
{
yield return(i);
}
var next = mode == EnumerateMode.Next ? r.NextCursor : r.PreviousCursor;
if (next == 0)
{
break;
}
prmList.RemoveAll(kvp => kvp.Key == "cursor");
prmList.Add(new KeyValuePair <string, object>("cursor", next));
r = tokens.AccessApiImpl <Cursored <T> >(MethodType.Get, apiName, prmList, "");
}
}
/// <summary>
/// Parse the specified json
/// </summary>
internal static StreamingMessage Parse(TokensBase tokens, string x)
{
var j = JObject.Parse(x);
try
{
if (j["text"] != null)
{
return(StatusMessage.Parse(tokens, j));
}
else if (j["friends"] != null)
{
return(CoreBase.Convert <FriendsMessage>(tokens, x));
}
else if (j["event"] != null)
{
return(EventMessage.Parse(tokens, j));
}
else if (j["for_user"] != null)
{
return(EnvelopesMessage.Parse(tokens, j));
}
else if (j["control"] != null)
{
return(CoreBase.Convert <ControlMessage>(tokens, x));
}
else
{
return(ExtractRoot(tokens, j));
}
}
catch (ParsingException)
{
throw;
}
catch (Exception e)
{
throw new ParsingException("on streaming, cannot parse the json", j.ToString(Formatting.Indented), e);
}
}
internal MediaMetadata(TokensBase e)
: base(e)
{
}
internal Trends(TokensBase e) : base(e)
{
}
internal Help(TokensBase e) : base(e)
{
}
internal Application(TokensBase e) : base(e)
{
}
internal DirectMessages(TokensBase e) : base(e)
{
}
internal Followers(TokensBase e) : base(e)
{
}
internal Friendships(TokensBase e) : base(e)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CoreTweet.Streaming.StreamingApi"/> class with a specified token.
/// </summary>
/// <param name="tokens"></param>
protected internal StreamingApi(TokensBase tokens) : base(tokens)
{
}
internal Mutes(TokensBase e) : base(e)
{
}
internal Media(TokensBase e) : base(e)
{
}
/// <summary>
/// Create a <see cref="CoreTweet.TwitterException"/> instance from the <see cref="System.Net.WebException"/>.
/// </summary>
/// <param name="tokens">OAuth tokens.</param>
/// <param name="ex">The thrown <see cref="System.Net.WebException"/>.</param>
/// <returns><see cref="CoreTweet.TwitterException"/> instance or null.</returns>
public static TwitterException Create(TokensBase tokens, WebException ex)
{
try
{
return from x in new StreamReader(ex.Response.GetResponseStream()).Use()
select new TwitterException(
(ex.Response as HttpWebResponse).StatusCode,
JObject.Parse(x.ReadToEnd())["errors"]
.Select(e => e.ToObject<Error>())
.ToArray(),
ex
);
}
catch
{
return null;
}
}
internal ApiProviderBase(TokensBase tokens)
{
Tokens = tokens;
}
/// <summary>
/// Get a stream from the specified url
/// </summary>
static StreamReader Connect(TokensBase e, StreamingParameters parameters, MethodType type, string url)
{
return(new StreamReader(e.SendRequest(type, url, parameters.Parameters)));
}
public static string GenerateCrcJsonResponse(this TokensBase tokens, string crcToken)
{
var res = SecurityUtils.HmacSha256(Encoding.UTF8.GetBytes(tokens.ConsumerSecret), Encoding.UTF8.GetBytes(crcToken));
return($"{{\"response_token\": \"sha256={Convert.ToBase64String(res)}\"}}");
}
internal static IEnumerable <T> Enumerate(TokensBase tokens, string apiName, EnumerateMode mode, params Expression <Func <string, object> >[] parameters)
{
var p = InternalUtils.ExpressionsToDictionary(parameters);
return(EnumerateImpl(tokens, apiName, mode, p));
}
internal V2Api(TokensBase e) : base(e)
{
}
internal Statuses(TokensBase e) : base(e)
{
}
internal static IEnumerable <T> Enumerate(TokensBase tokens, string apiName, EnumerateMode mode, IDictionary <string, object> parameters)
{
return(EnumerateImpl(tokens, apiName, mode, parameters));
}
internal Blocks(TokensBase e) : base(e)
{
}
internal static IEnumerable <T> Enumerate(TokensBase tokens, string apiName, EnumerateMode mode, object parameters)
{
var p = InternalUtils.ResolveObject(parameters);
return(EnumerateImpl(tokens, apiName, mode, p));
}
internal Mutes(TokensBase e)
: base(e)
{
}
internal AccountActivityApi(TokensBase e) : base(e)
{
}
internal Media(TokensBase e)
: base(e)
{
}
public AccountActivityEnvironment(TokensBase e, string env_name) : base(e)
{
EnvName = env_name;
}
internal Users(TokensBase e) : base(e)
{
}
/// <summary>
/// Get a stream from the specified url
/// </summary>
static StreamReader Connect(TokensBase e, StreamingParameters parameters, MethodType type, string url)
{
return new StreamReader(e.SendRequest(type, url, parameters.Parameters));
}
