private async void OnSystemMessage(Xmpp.Im.Message xmppXmppMessage)
{
var notificationType = GetNotificationType(xmppXmppMessage.ExtraParameters);
SystemMessage systemMessage = null;
if (notificationType == NotificationTypes.GroupCreate || notificationType == NotificationTypes.GroupUpdate)
{
systemMessage = new GroupInfoMessage();
FillSystemMessageFields(xmppXmppMessage, systemMessage);
FillGroupInfoMessageFields(xmppXmppMessage.ExtraParameters, (GroupInfoMessage)systemMessage);
}
else
{
systemMessage = new SystemMessage();
FillSystemMessageFields(xmppXmppMessage, systemMessage);
}
systemMessage.ExtraParameters = xmppXmppMessage.ExtraParameters;
await LoggerHolder.Log(LogLevel.Debug, "XMPP: OnMessageReceived ====> " +
" From: " + systemMessage.SenderId +
" Body: " + systemMessage.MessageText +
" FullXmlMessage: " + xmppXmppMessage.DataString);
var handler = SystemMessageReceived;
if (handler != null)
{
var systemMessageEventArgs = new SystemMessageEventArgs(new Jid(xmppXmppMessage.From.ToString()), systemMessage, xmppXmppMessage.Type);
handler.Invoke(this, systemMessageEventArgs);
}
}
private async void OnUsualMessage(Xmpp.Im.Message xmppXmppMessage)
{
var receivedMessage = new GeneralDataModel.Models.Message();
FillUsualMessageFields(xmppXmppMessage, receivedMessage);
FillUsualMessageExtraParamsFields(xmppXmppMessage.ExtraParameters, receivedMessage);
FillAttachments(xmppXmppMessage.ExtraParameters, receivedMessage);
await LoggerHolder.Log(LogLevel.Debug, "XMPP: OnMessageReceived ====> " +
" From: " + receivedMessage.SenderId +
" To: " + receivedMessage.RecipientId +
" Body: " + receivedMessage.MessageText +
" DateSent " + receivedMessage.DateSent +
" FullXmlMessage: " + xmppXmppMessage.DataString);
receivedMessage.ExtraParameters = xmppXmppMessage.ExtraParameters;
var handler = MessageReceived;
if (handler != null)
{
var messageEventArgs = new MessageEventArgs(xmppXmppMessage.From, receivedMessage, xmppXmppMessage.Type);
handler.Invoke(this, messageEventArgs);
}
}
public BotManagerBuilder AddLogger(ILogger logger)
{
LoggerHolder.Init(logger);
LoggerHolder.Instance.Information("Logger was initialized");
return(this);
}
public void SendMessage(string jid, string body, XElement extraParams = null, string dialogId = null, string subject = null, MessageType messageType = MessageType.Chat)
{
var messageId = MongoObjectIdGenerator.GetNewObjectIdString();
var message = xmppClient.SendMessage(jid, messageId, body, subject, dialogId, extraParams, messageType);
LoggerHolder.Log(LogLevel.Debug, "XMPP: SentMessage ====> " + message.DataString);
}
public void SendMessage(int userId, string body, XElement extraParams = null, string dialogId = null, string subject = null, MessageType messageType = MessageType.Chat)
{
var messageId = MongoObjectIdGenerator.GetNewObjectIdString();
var wrappedMessageType = (Xmpp.Im.MessageType)Enum.Parse(typeof(Xmpp.Im.MessageType), messageType.ToString());
var jidString = BuildJid(userId, quickbloxClient.ApplicationId, quickbloxClient.ChatEndpoint);
var jid = new Xmpp.Jid(jidString);
var message = xmppClient.SendMessage(jid, messageId, body, subject, dialogId, extraParams, wrappedMessageType);
LoggerHolder.Log(LogLevel.Debug, "XMPP: SentMessage ====> " + message.DataString);
}
public static async Task <String> DeleteAsync(String baseAddress, String requestUri, IDictionary <String, IEnumerable <String> > headers = null, CancellationToken token = default(CancellationToken))
{
var response = await DeleteBaseAsync(baseAddress, requestUri, headers, token).ConfigureAwait(false);
var stringContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
await LoggerHolder.Log(LogLevel.Debug, "DELETE RESPONSE CONTENT: " + stringContent);
return(stringContent);
}
private async void OnSubscriptionApprovedCallback(object sender, Xmpp.Im.SubscriptionApprovedEventArgs e)
{
await LoggerHolder.Log(LogLevel.Debug, "XMPP: ====> OnSubscriptionApproved:" + e.Jid.ToString());
var handler = SubscriptionsChanged;
if (handler != null)
{
handler.Invoke(this, new SubscriptionsEventArgs(e.Jid, PresenceType.Subscribed));
}
}
private async void OnClientErrorCallback(object sender, Xmpp.Im.ErrorEventArgs args)
{
await LoggerHolder.Log(LogLevel.Debug, "XMPP: ====> OnClientError:" +
" Exception: " + args.ToString());
var handler = ErrorReceived;
if (handler != null)
{
handler.Invoke(sender, new ErrorEventArgs(args.Exception));
}
}
protected static async Task <HttpResponseMessage> PostBaseAsync(String baseAddress, String requestUri, HttpContent content, IEnumerable <KeyValuePair <String, IEnumerable <String> > > headers, CancellationToken token)
{
HttpResponseMessage response;
using (var handler = new HttpClientHandler())
{
using (var client = new HttpClient(handler))
{
client.BaseAddress = new Uri(baseAddress);
if (handler.SupportsAutomaticDecompression)
{
handler.AutomaticDecompression = DecompressionMethods.GZip;
client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("deflate"));
}
else
{
client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("identity"));
}
client.DefaultRequestHeaders.CacheControl = new CacheControlHeaderValue {
NoCache = true, NoStore = true
};
client.DefaultRequestHeaders.SetRequestHeaders(headers);
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine(String.Concat("==> POST REQUEST: ", baseAddress, requestUri));
stringBuilder.AppendLine(String.Concat("==> POST HEADERS: ", client.DefaultRequestHeaders));
stringBuilder.AppendLine(String.Concat("==> POST CONTENT: ", await content.ReadAsStringAsync()));
await LoggerHolder.Log(LogLevel.Debug, stringBuilder.ToString());
try
{
response = await client.PostAsync(requestUri, content, token).ConfigureAwait(false);
}
catch (HttpRequestException)
{
response = new HttpResponseMessage(HttpStatusCode.NotFound);
response.Content = new StringContent("Error internet connection");
}
catch (Exception ex)
{
response = new HttpResponseMessage(HttpStatusCode.NotFound);
response.Content = new StringContent("Error internet connection");
}
await LoggerHolder.Log(LogLevel.Debug, String.Concat("<== POST RESPONSE: ", response));
Interlocked.Exchange(ref ticks, DateTime.UtcNow.Ticks);
}
}
return(response);
}
private async void OnChatStateChangedCallback(object sender, Xmpp.Extensions.ChatStateChangedEventArgs e)
{
await LoggerHolder.Log(LogLevel.Debug, "XMPP: ====> OnChatStateChanged:" +
" Jid: " + e.Jid +
" ChatState: " + e.ChatState.ToString());
var handler = ChatStateChanged;
if (handler != null)
{
handler.Invoke(this, new ChatStateChangedEventArgs(e.Jid, e.ChatState));
}
}
private async void OnMoodChangedCallback(object sender, Xmpp.Extensions.MoodChangedEventArgs e)
{
await LoggerHolder.Log(LogLevel.Debug, "XMPP: ====> OnMoodChanged:" +
" Description: " + e.Description +
" Jid: " + e.Jid + " Mood state: " + e.Mood);
var handler = MoodStateChanged;
if (handler != null)
{
handler.Invoke(this, new MoodChangedEventArgs(new Jid(e.Jid.ToString()), e.Mood, e.Description));
}
}
private async void OnActivityChangedCallback(object sender, Xmpp.Extensions.ActivityChangedEventArgs e)
{
await LoggerHolder.Log(LogLevel.Debug, "XMPP: ====> OnActivityChanged:" +
" Jid: " + e.Jid +
" ChatState: " + e.Activity.ToString());
Debug.WriteLine("XMPP: ====> OnActivityChanged:");
var handler = ActivityChanged;
if (handler != null)
{
handler.Invoke(this, new ActivityChangedEventArgs(e.Jid, e.Activity.ToString(), e.Specific.ToString(), e.Description));
}
}
private static async Task <String> PutAsync(String baseAddress, String requestUri, IEnumerable <KeyValuePair <String, String> > nameValueCollection, IEnumerable <KeyValuePair <String, IEnumerable <String> > > headers, CancellationToken token)
{
HttpResponseMessage response;
using (var httpContent = new FormUrlEncodedContent(nameValueCollection))
{
response = await PutBaseAsync(baseAddress, requestUri, httpContent, headers, token).ConfigureAwait(false);
}
var stringContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
await LoggerHolder.Log(LogLevel.Debug, "PUT RESPONSE CONTENT: " + stringContent);
return(stringContent);
}
private async void OnRosterUpdatedCallback(object sender, Xmpp.Im.RosterUpdatedEventArgs e)
{
await LoggerHolder.Log(LogLevel.Debug, "XMPP: ====> OnRosterUpdated:" +
" IsRemoved: " + e.Removed +
" Jid: " + e.Item.Jid +
" Name: " + e.Item.Name +
" SubscriptionState: " + e.Item.SubscriptionState);
var handler = RosterUpdated;
if (handler != null)
{
handler.Invoke(this, new RosterUpdatedEventArgs(e.Item, e.Removed));
}
}
public static async Task <String> PostAsync(String baseAddress, String requestUri, Byte[] data, IDictionary <String, IEnumerable <String> > headers = null, CancellationToken token = default(CancellationToken))
{
HttpResponseMessage response;
using (var multiPartContent = new MultipartFormDataContent())
{
var imageContent = new ByteArrayContent(data);
imageContent.Headers.ContentType = MediaTypeHeaderValue.Parse("image/jpeg");
multiPartContent.Add(imageContent, "image", "image.jpg");
response = await PostBaseAsync(baseAddress, requestUri, multiPartContent, headers, token).ConfigureAwait(false);
}
var stringContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
await LoggerHolder.Log(LogLevel.Debug, "POST RESPONSE CONTENT: " + stringContent);
return(stringContent);
}
private static async Task <HttpResponse <TResult> > ParseResult <TResult>(ISerializer serializer, HttpResponseMessage response)
{
var stringContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
await LoggerHolder.Log(LogLevel.Debug, String.Concat("CONTENT: ", stringContent));
HttpResponse <TResult> httpResponse = new HttpResponse <TResult>();
serializer = serializer ?? (response.Content.Headers.ContentType != null ? FactorySerializer.CreateSerializer(response.Content.Headers.ContentType.MediaType) : FactorySerializer.CreateSerializer());
if (response.IsSuccessStatusCode)
{
if (!string.IsNullOrWhiteSpace(stringContent))
{
httpResponse.Result = serializer.Deserialize <TResult>(stringContent);
httpResponse.RawData = stringContent;
}
}
else
{
try
{
var error = serializer.Deserialize <ErrorResponse>(stringContent);
httpResponse.Errors = error.Errors;
}
catch (Exception)
{
httpResponse.Errors = new Dictionary <string, string[]>();
if (!string.IsNullOrWhiteSpace(stringContent))
{
httpResponse.Errors.Add("Unknown", new[] { stringContent });
}
else
{
httpResponse.Errors.Add("Not Found", new[] { "Not Found" });
}
}
}
httpResponse.StatusCode = response.StatusCode;
return(httpResponse);
}
private async void OnTuneCallback(object sender, Xmpp.Extensions.TuneEventArgs e)
{
await LoggerHolder.Log(LogLevel.Debug, "XMPP: ====> OnTune:");
var handler = Tune;
if (handler != null)
{
var jid = new Jid(e.Jid.ToString());
TuneInformation information = null;
if (e.Information != null)
{
information = new TuneInformation(e.Information.Title, e.Information.Artist, e.Information.Track, e.Information.Length, e.Information.Rating, e.Information.Source, e.Information.Uri);
}
handler.Invoke(this, new TuneEventArgs(jid, information));
}
await LoggerHolder.Log(LogLevel.Debug, "XMPP: ====> ============///////////////////////==============");
}
public static async Task <HttpResponse <Byte[]> > GetBytesAsync(String baseAddress, String requestUri,
IDictionary <String, IEnumerable <String> > headers = null,
ISerializer serializer = null,
CancellationToken token = default(CancellationToken))
{
var response = await GetBaseAsync(baseAddress, requestUri, headers, token).ConfigureAwait(false);
HttpResponse <Byte[]> httpResponse = new HttpResponse <Byte[]>();
if (response.IsSuccessStatusCode)
{
httpResponse.Result = await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
await LoggerHolder.Log(LogLevel.Debug, String.Concat("CONTENT: ", "Byte[] content. Length:", httpResponse.Result.Length));
}
else
{
var stringContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
await LoggerHolder.Log(LogLevel.Debug, String.Concat("CONTENT: ", stringContent));
try
{
serializer = serializer ??
FactorySerializer.CreateSerializer(response.Content.Headers.ContentType.MediaType);
var error = serializer.Deserialize <ErrorResponse>(stringContent);
httpResponse.Errors = error.Errors;
}
catch (Exception)
{
httpResponse.Errors = new Dictionary <string, string[]>();
httpResponse.Errors.Add(" ", new [] { stringContent });
}
}
httpResponse.StatusCode = response.StatusCode;
return(httpResponse);
}
private async void OnStatusChangedCallback(object sender, Xmpp.Im.StatusEventArgs e)
{
if (MyJid == null)
{
return;
}
await LoggerHolder.Log(LogLevel.Debug, "XMPP: ====> OnStatusChanged:" + e.Jid.ToString() + " Status: " + e.Status.Availability);
if (e.Jid != new Xmpp.Jid(MyJid.ToString()))
{
var jid = e.Jid.ToString();
if (e.Status.Availability == Xmpp.Im.Availability.Online)
{
if (!this.Presences.Contains(jid))
{
await LoggerHolder.Log(LogLevel.Debug, "XMPP: ====> Added to Presences. Jid: " + e.Jid);
this.Presences.Add(jid);
}
}
else
{
await LoggerHolder.Log(LogLevel.Debug, "XMPP: ====> Removed from Presences. Jid: " + e.Jid);
this.Presences.Remove(jid);
}
}
var handler = StatusChanged;
if (handler != null)
{
var availability = (Availability)Enum.Parse(typeof(Availability), e.Status.Availability.ToString());
var status = new Status(availability, e.Status.Messages, e.Status.Priority);
handler.Invoke(this, new StatusEventArgs(e.Jid, status));
}
}
