public async Task Send(string message)
{
SlackTaskClient slackClient = new SlackTaskClient(_provider.AccessCode);
PostMessageResponse response = await slackClient.PostMessageAsync(_provider.ChannelName, message);
Console.WriteLine(response.error);
}
public async Task PostGetMessageListContinuationTokenTest()
{
var conversation = CreateRandomPostConversationRequest();
var fetchedConversation = await _chatServiceClient.AddConversation(conversation);
PostMessageResponse[] sentMessageList = new PostMessageResponse[6];
for (int messageCount = 0; messageCount < 6; messageCount++)
{
sentMessageList[messageCount] = await _chatServiceClient.AddMessage(fetchedConversation.Id, CreateRandomPostMessageRequest());
}
GetMessagesResponse fetchedMessageList1 = await _chatServiceClient.GetMessageList(fetchedConversation.Id, 3, sentMessageList[0].UnixTime);
Assert.Equal(3, fetchedMessageList1.Messages.Count());
Assert.Equal(fetchedMessageList1.Messages.ElementAt(0).Text, sentMessageList[5].Text);
Assert.Equal(fetchedMessageList1.Messages.ElementAt(1).Text, sentMessageList[4].Text);
Assert.Equal(fetchedMessageList1.Messages.ElementAt(2).Text, sentMessageList[3].Text);
Assert.NotEmpty(fetchedMessageList1.NextUri);
GetMessagesResponse fetchedMessageList2 = await _chatServiceClient.GetMessageList(fetchedMessageList1.NextUri);
Assert.Equal(2, fetchedMessageList2.Messages.Count());
Assert.Equal(fetchedMessageList2.Messages.ElementAt(0).Text, sentMessageList[2].Text);
Assert.Equal(fetchedMessageList2.Messages.ElementAt(1).Text, sentMessageList[1].Text);
Assert.Empty(fetchedMessageList2.NextUri);
}
public void BlocksInAttachment()
{
// given
var client = this.fixture.UserClient;
PostMessageResponse actual = null;
// when
using (var sync = new InSync(nameof(SlackClient.PostMessage)))
{
client.PostMessage(
response =>
{
actual = response;
sync.Proceed();
},
this.fixture.Config.TestChannel,
"These blocks are in an attachment",
attachments: new []
{
new Attachment
{
blocks = SlackMother.SomeBlocks
}
});
}
// then
Assert.True(actual.ok, "Error while posting message to channel. ");
}
private async void SendMessagetoUser(String message_text, string number)
{
try
{
using (var client = new HttpClient())
{
string url = ConstructBaseUri();
client.BaseAddress = new Uri(url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password))
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Basic",
Convert.ToBase64String(
ASCIIEncoding.ASCII.GetBytes(
string.Format("{0}:{1}", username, password))));
}
var postData = new List <KeyValuePair <string, string> >();
postData.Add(new KeyValuePair <string, string>("to", number));
postData.Add(new KeyValuePair <string, string>("message", message_text));
HttpContent content = new FormUrlEncodedContent(postData);
HttpResponseMessage response = await client.PostAsync(MessagesUrlPath, content);
if (response.IsSuccessStatusCode)
{
PostMessageResponse result = await response.Content.ReadAsAsync <PostMessageResponse>();
if (result.IsSuccessful)
{
// MessageBox.Show("Sent");
// message_sent = true;
// txtLogs.Text += DateTime.Now + "-" + ("Message Sent to User ..." + "\r\n");
}
else
{
// MessageBox.Show(result.ToString());
}
}
else
{
}
}
}
catch (Exception ex)
{
// MessageBox.Show(ex.Message);
}
finally
{
}
}
public async Task <PostConversationResponse> PostConversation(PostConversationRequest postConversationRequest, string conversationId)
{
using (_logger.BeginScope("{ConversationId}", conversationId))
{
PostMessageResponse message = new PostMessageResponse
{
Id = postConversationRequest.FirstMessage.Id,
Text = postConversationRequest.FirstMessage.Text,
SenderUsername = postConversationRequest.FirstMessage.SenderUsername,
UnixTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
};
PostConversationResponse conversation = new PostConversationResponse
{
Id = conversationId,
CreatedUnixTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
};
var stopWatch = Stopwatch.StartNew();
await _messageStore.AddMessage(message, conversationId);
var fetchedConversation = await _conversationStore.AddConversation(conversation, postConversationRequest.Participants);
_telemetryClient.TrackMetric("ConversationStore.AddConversation.Time", stopWatch.ElapsedMilliseconds);
_telemetryClient.TrackEvent("ConversationAdded");
return(fetchedConversation);
}
}
private IEnumerator PostRequest(string url, string jsonBody)
{
UnityWebRequest request = new UnityWebRequest(url, "POST");
byte[] rawBody = new System.Text.UTF8Encoding().GetBytes(jsonBody);
request.uploadHandler = (UploadHandler) new UploadHandlerRaw(rawBody);
request.downloadHandler = (DownloadHandler) new DownloadHandlerBuffer();
request.SetRequestHeader("Content-Type", "application/json");
yield return(request.SendWebRequest());
PostMessageResponse response = JsonUtility.FromJson <PostMessageResponse>(request.downloadHandler.text);
if (request.isHttpError || request.isNetworkError)
{
Debug.LogWarning("Request returned web error");
emotionRequest = null;
yield break;
}
Debug.Log("Emotion: " + response.emotion);
ResponseReceived?.Invoke(response.emotion);
emotionRequest = null;
}
private static DocumentDbMessageEntity ToEntity(string conversationId, PostMessageResponse message)
{
return(new DocumentDbMessageEntity
{
PartitionKey = $"m_{conversationId}",
Id = message.Id,
Text = message.Text,
SenderUsername = message.SenderUsername,
UnixTime = message.UnixTime
});
}
public PostMessageResponse CreateRandomPostMessageResponse(string senderUsername)
{
string id = CreateRandomString();
string text = CreateRandomString();
var message = new PostMessageResponse
{
Id = id,
Text = text,
SenderUsername = senderUsername,
UnixTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
};
return(message);
}
public IResponseData <PostMessageResponse> Post(PostMessageRequest request)
{
IResponseData <PostMessageResponse> response = new ResponseData <PostMessageResponse>();
try
{
IMessageService service = IoC.Container.Resolve <IMessageService>();
PostMessageResponse postResult = service.Post(request);
response.SetData(postResult);
}
catch (ValidationException ex)
{
response.SetErrors(ex.Errors);
response.SetStatus(HttpStatusCode.PreconditionFailed);
}
return(response);
}
public async Task PostGetMessageListLastSeenMessageTimeTest(int indexOfLastSeenMessage)
{
var conversation = CreateRandomPostConversationRequest();
var fetchedConversation = await _chatServiceClient.AddConversation(conversation);
PostMessageResponse[] sentMessageList = new PostMessageResponse[11];
for (int messageCount = 0; messageCount < 11; messageCount++)
{
sentMessageList[messageCount] = await _chatServiceClient.AddMessage(fetchedConversation.Id, CreateRandomPostMessageRequest());
}
GetMessagesResponse fetchedMessageList = await _chatServiceClient.GetMessageList(fetchedConversation.Id, 30, sentMessageList[indexOfLastSeenMessage].UnixTime);
int numberOfMessagesfetched = 10 - indexOfLastSeenMessage;
Assert.Equal(numberOfMessagesfetched, fetchedMessageList.Messages.Count());
Assert.Empty(fetchedMessageList.NextUri);
}
public async Task <PostMessageResponse> AddMessage(PostMessageResponse message, string conversationId)
{
try
{
var entity = ToEntity(conversationId, message);
await _documentClient.CreateDocumentAsync(DocumentCollectionUri, entity);
return(message);
}
catch (DocumentClientException e)
{
if ((int)e.StatusCode == 409)
{
var originalMessage = await GetMessage(conversationId, message.Id);
return(originalMessage);
}
throw new StorageErrorException($"Failed to add message {message.Id} to conversation {conversationId}", e);
}
}
public async Task <PostMessageResponse> PostMessage(string conversationId, PostMessageRequest postMessageRequest)
{
using (_logger.BeginScope("{MessageId}", postMessageRequest.Id))
{
PostMessageResponse message = new PostMessageResponse
{
Id = postMessageRequest.Id,
Text = postMessageRequest.Text,
SenderUsername = postMessageRequest.SenderUsername,
UnixTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
};
var stopWatch = Stopwatch.StartNew();
var fetchedMessage = await _messageStore.AddMessage(message, conversationId);
await _conversationStore.UpdateConversation(conversationId, fetchedMessage.UnixTime);
_telemetryClient.TrackMetric("MessageStore.AddMessage.Time", stopWatch.ElapsedMilliseconds);
_telemetryClient.TrackEvent("MessageAdded");
return(fetchedMessage);
}
}
public void PostTextMessage(string channelName, string msg)
{
var client = BotClient;
PostMessageResponse actual = null;
using (var sync = new InSync(nameof(SlackClient.PostMessage)))
{
client.GetChannelList(clr => { Console.WriteLine("got channels"); });
var c = client.Channels.Find(x => x.name == channelName);
client.PostMessage(
response =>
{
Console.WriteLine($"sent message to {channelName}!");
actual = response;
sync.Proceed();
},
c.id,
msg);
}
Console.WriteLine(!actual.ok ? "Error while posting message to channel. " : $"{actual.ts}:{actual.message.text}");
}
public PostMessageResponse <Success, Exception> Send(Message message)
{
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _token);
var request = JsonConvert.SerializeObject(new PostMessageRequest
{
Channel = message.Channel,
Text = message.Text
});
var content = new StringContent(request, Encoding.UTF8, "application/json");
var response = PostChatMessageAsync(content);
response.Wait();
if ((bool)response.Result["ok"])
{
return(PostMessageResponse <Success, Exception> .OfSuccessful(new Success()));
}
return(PostMessageResponse <Success, Exception>
.OfError(new Exception(response.Result["error"].ToString() ?? "Default error message")));
}
public void AttachmentsWithActions()
{
// given
var client = this.fixture.UserClient;
PostMessageResponse actual = null;
// when
using (var sync = new InSync())
{
client.PostMessage(
response =>
{
actual = response;
sync.Proceed();
},
this.fixture.Config.TestChannel,
string.Empty,
attachments: SlackMother.SomeAttachmentsWithActions);
}
// then
Assert.True(actual.ok, "Error while posting message to channel. ");
}
public void Attachments()
{
// given
var client = ClientHelper.GetClient(_config.Slack.UserAuthToken);
PostMessageResponse actual = null;
// when
using (var sync = new InSync())
{
client.PostMessage(
response =>
{
actual = response;
sync.Proceed();
},
_config.Slack.TestChannel,
string.Empty,
attachments: SlackMother.SomeAttachments);
}
// then
Assert.IsTrue(actual.ok, "Error while posting message to channel. ");
}
public void SimpleMessageDelivery()
{
// given
var client = this.fixture.UserClient;
PostMessageResponse actual = null;
// when
using (var sync = new InSync(nameof(SlackClient.PostMessage)))
{
client.PostMessage(
response =>
{
actual = response;
sync.Proceed();
},
this.fixture.Config.TestChannel,
"Hi there!");
}
// then
Assert.True(actual.ok, "Error while posting message to channel. ");
Assert.Equal("Hi there!", actual.message.text);
Assert.Equal("message", actual.message.type);
}
public void SimpleMessageDelivery()
{
// given
var client = ClientHelper.GetClient(_config.Slack.UserAuthToken);
PostMessageResponse actual = null;
// when
using (var sync = new InSync())
{
client.PostMessage(
response =>
{
actual = response;
sync.Proceed();
},
_config.Slack.TestChannel,
"Hi there!");
}
// then
Assert.IsTrue(actual.ok, "Error while posting message to channel. ");
Assert.AreEqual(actual.message.text, "Hi there!");
Assert.AreEqual(actual.message.type, "message");
}
public SingleMessageHandle(PostMessageResponse messageResponse)
: this(messageResponse.ts, messageResponse.channel)
{
}
public async Task <string> SendMessage(string PhoneNumber, string Message)
{
string finalresponse = "";
if (PhoneNumber == "" || Message == "")
{
finalresponse = "Invalid Parameters";
}
else
{
String strConnString = "Data Source=192.168.10.6;Initial Catalog=SMS;Integrated Security=False;user id=OnlineServices;password=Whanganui497";
SqlConnection con = new SqlConnection(strConnString);
SqlCommand cmd = new SqlCommand("GET_PARAMETER", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@parameter", SqlDbType.VarChar).Value = "IPAddress";
cmd.Connection = con;
try
{
con.Open();
//SqlDataReader dr = cmd.ExecuteReader();
IPAddress = cmd.ExecuteScalar().ToString();
}
catch (Exception ex)
{
//Console.WriteLine(ex.Message);
//Console.WriteLine(ex.InnerException);
throw ex;
}
finally
{
con.Close();
}
cmd.Parameters.Clear();
cmd.Parameters.Add("@parameter", SqlDbType.VarChar).Value = "Port";
cmd.Connection = con;
try
{
con.Open();
//SqlDataReader dr = cmd.ExecuteReader();
Port = cmd.ExecuteScalar().ToString();
}
catch (Exception ex)
{
//Console.WriteLine(ex.Message);
//Console.WriteLine(ex.InnerException);
throw ex;
}
finally
{
con.Close();
}
using (var client = new HttpClient())
{
string url = ConstructBaseUri();
client.BaseAddress = new Uri(url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (!string.IsNullOrEmpty(UserName) && !string.IsNullOrEmpty(Password))
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Basic",
Convert.ToBase64String(
ASCIIEncoding.ASCII.GetBytes(
string.Format("{0}:{1}", UserName, Password))));
}
var postData = new List <KeyValuePair <string, string> >();
postData.Add(new KeyValuePair <string, string>("to", PhoneNumber));
postData.Add(new KeyValuePair <string, string>("message", Message));
HttpContent content = new FormUrlEncodedContent(postData);
HttpResponseMessage response = await client.PostAsync(MessagesUrlPath, content);
if (response.IsSuccessStatusCode)
{
PostMessageResponse result = await response.Content.ReadAsAsync <PostMessageResponse>();
if (result.IsSuccessful)
{
finalresponse = result.ToString();
}
else
{
finalresponse = result.Description;
}
}
else
{
finalresponse = response.ToString();
}
}
}
return(finalresponse);
}
private void ProcessCompletion(TaskCompletionSource <SlackMessage> ts, string channel, PostMessageResponse msg)
{
try
{
ts.SetResult(SlackMessage.Create(this, channel, msg.message));
}
catch (Exception e)
{
ts.SetException(e);
Console.WriteLine(msg.error);
Console.WriteLine(e);
}
}
private async void SendMessage()
{
if (string.IsNullOrEmpty(txtIPAddress.Text))
{
MessageBox.Show("Please enter an IP address", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
txtIPAddress.Focus();
return;
}
if (string.IsNullOrEmpty(txtContact.Text) || string.IsNullOrEmpty(txtMessage.Text))
{
MessageBox.Show("Please enter the contact name/number and the message", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
txtContact.Focus();
return;
}
try
{
btnSendMessage.Enabled = false;
using (var client = new HttpClient())
{
string url = ConstructBaseUri();
client.BaseAddress = new Uri(url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (!string.IsNullOrEmpty(txtUserName.Text) && !string.IsNullOrEmpty(txtPassword.Text))
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Basic",
Convert.ToBase64String(
ASCIIEncoding.ASCII.GetBytes(
string.Format("{0}:{1}", txtUserName.Text, txtPassword.Text))));
}
var postData = new List <KeyValuePair <string, string> >();
postData.Add(new KeyValuePair <string, string>("to", txtContact.Text));
postData.Add(new KeyValuePair <string, string>("message", txtMessage.Text));
HttpContent content = new FormUrlEncodedContent(postData);
HttpResponseMessage response = await client.PostAsync(MessagesUrlPath, content);
if (response.IsSuccessStatusCode)
{
PostMessageResponse result = await response.Content.ReadAsAsync <PostMessageResponse>();
if (result.IsSuccessful)
{
txtOutput.Clear();
AddToOutput(result.ToString());
AddToOutput("");
}
else
{
MessageBox.Show(result.Description, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
MessageBox.Show(response.ToString(), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
btnSendMessage.Enabled = true;
}
}
private async void SendMessagetoUser(String message_text, string number)
{
message_sent = false;
if (string.IsNullOrEmpty(txtIPAddress.Text))
{
//MessageBox.Show("Please enter an IP address", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
txtIPAddress.Focus();
return;
}
try
{
using (var client = new HttpClient())
{
string url = ConstructBaseUri();
client.BaseAddress = new Uri(url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (!string.IsNullOrEmpty(txtUserName.Text) && !string.IsNullOrEmpty(txtPassword.Text))
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Basic",
Convert.ToBase64String(
ASCIIEncoding.ASCII.GetBytes(
string.Format("{0}:{1}", txtUserName.Text, txtPassword.Text))));
}
var postData = new List <KeyValuePair <string, string> >();
postData.Add(new KeyValuePair <string, string>("to", number));
postData.Add(new KeyValuePair <string, string>("message", message_text));
HttpContent content = new FormUrlEncodedContent(postData);
HttpResponseMessage response = await client.PostAsync(MessagesUrlPath, content);
if (response.IsSuccessStatusCode)
{
PostMessageResponse result = await response.Content.ReadAsAsync <PostMessageResponse>();
if (result.IsSuccessful)
{
message_sent = true;
txtLogs.Text += DateTime.Now + "-" + ("Message Sent to User ..." + "\r\n");
}
else
{
txtLogs.Text += DateTime.Now + "-" + ("Unable to Send Message..." + "\r\n");
}
}
else
{
txtLogs.Text += DateTime.Now + "-" + ("Unable to Send Message..." + "\r\n");
}
}
}
catch (Exception ex)
{
txtLogs.Text += DateTime.Now + "-" + ("Unable to Send Command..." + "\r\n");
}
finally
{
}
}
public PostMessageResponse <Success, Exception> Send(Message message)
{
Message = message;
return(PostMessageResponse <Success, Exception> .OfSuccessful(new Success()));
}
private async void SendMessage(String message_text, int log_id)
{
message_sent = false;
//if (message_text.StartsWith("loc", true, null))
//{
// if(message_text.Length>15){
// string number = message_text.Substring(4, 12);
// string net = getNetwork(number);
// //MessageBox.Show("Number is= "+number +"Netwotk is "+net);
// string command = "";
// string address = "";
// string subj = "";
// if (net.Equals("mobilink"))
// {
// subj = "Loc Query";
// command = number;
// address = "*****@*****.**";
// }
// else if (net.Equals("warid"))
// {
// subj = "Location Query";
// command = number;
// address = "*****@*****.**";
// }
// else if (net.Equals("ufone"))
// {
// subj = number;
// command = "";
// address = "*****@*****.**";
// }
// else if (net.Equals("zong"))
// {
// subj = "FIR";
// command = "Location Please = " + number;
// address = "*****@*****.**";
// }
// else if (net.Equals("telenor"))
// {
// subj = "FIR";
// command = "Loc " + number;
// address = "*****@*****.**";
// }
// txtLogs.Text = subj + " Command= " + command + " Address= " + address;
// if (sendCommand(subj, command, address))
// {
// txtLogs.Text += DateTime.Now + "-" + ("Email Command Sent..." + "\r\n");
// }
// }
// return;
//}
string sender_number;
if (message_text.StartsWith("cnic", true, null) || message_text.StartsWith("sub", true, null) || message_text.StartsWith("vehicle", true, null))
{
sender_number = server_number155;
// server_number = server_number155;
}
else
{
sender_number = server_number;
}
try
{
using (var client = new HttpClient())
{
string url = ConstructBaseUri();
client.BaseAddress = new Uri(url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (!string.IsNullOrEmpty(txtUserName.Text) && !string.IsNullOrEmpty(txtPassword.Text))
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Basic",
Convert.ToBase64String(
ASCIIEncoding.ASCII.GetBytes(
string.Format("{0}:{1}", txtUserName.Text, txtPassword.Text))));
}
var postData = new List <KeyValuePair <string, string> >();
postData.Add(new KeyValuePair <string, string>("to", sender_number));
postData.Add(new KeyValuePair <string, string>("message", message_text));
HttpContent content = new FormUrlEncodedContent(postData);
HttpResponseMessage response = await client.PostAsync(MessagesUrlPath, content);
if (response.IsSuccessStatusCode)
{
PostMessageResponse result = await response.Content.ReadAsAsync <PostMessageResponse>();
if (result.IsSuccessful)
{
message_sent = true;
//Update log
BLL.tb_log log = new BLL.tb_log();
log.logger_id = log_id;
log.to_command_time_stamp = DateTime.Now;
log.isCommandSent = true;
if (log.UpdateCommandSentToServer(log))
{
// txtLogs.Text += DateTime.Now + "-" + ("Message Sent to Server for Processing..." + "\r\n");
txtLogs.Text += DateTime.Now + "-" + ("Command Sent to " + sender_number + " - Command - " + message_text + "\r\n");
txtLogs.ForeColor = Color.Magenta;
}
}
else
{
txtLogs.Text += DateTime.Now + "-" + ("Unable to Send Command..." + "\r\n");
}
}
else
{
txtLogs.Text += DateTime.Now + "-" + ("Unable to Send Command..." + "\r\n");
}
}
}
catch (Exception ex)
{
txtLogs.Text += DateTime.Now + "-" + ("Unable to Send Command..." + "\r\n");
}
}
