public void Given_There_Are_No_Unread_Messages_Return_No_Messages()
{
_messageDeliveredToServer.MarkAsReceived();
var messageResponse = _subjectUnderTest.GetFirstUnreadMessage(new GetMessageRequest {
RecipientId = "1"
});
var message = messageResponse.Result;
var expectedMessage = new GetMessageResponse();
var expectedMessageDeliveredToRecipient = new Message("0", "1", "0 to 1: Delivered to 1", _messageDeliveredToRecipient.Id);
expectedMessageDeliveredToRecipient.MarkAsReceived();
var anotherExpectedMessageDeliveredToRecipient = new Message("0", "1", "0 to 1: Delivered to the server", _messageDeliveredToServer.Id);
anotherExpectedMessageDeliveredToRecipient.MarkAsReceived();
var expectedMessages = new List <Message>
{
expectedMessageDeliveredToRecipient,
anotherExpectedMessageDeliveredToRecipient
};
message.Should().Be(expectedMessage);
_messages.Should().BeEquivalentTo(expectedMessages);
}
public static GetMessageResponse GetMessages(string Mailbox)
{
if (Membership.GetUser() == null || !Membership.GetUser().IsApproved)
{
return(new GetMessageResponse(false));
}
MessageManager messageMgr = new MessageManager();
GetMessageResponse response = new GetMessageResponse(true);
if (Mailbox != "New")
{
response.messages = messageMgr.GetMailbox(Membership.GetUser().UserName, Mailbox);
}
else
{
response.messages = messageMgr.GetUnreadInbox(Membership.GetUser().UserName);
}
response.NewCount = messageMgr.CountMessages(Membership.GetUser().UserName, "New");
response.InboxCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Inbox");
response.SentCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Sent");
response.TrashCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Trash");
messageMgr.Dispose();
return(response);
}
private void DownloadMessageFile(GetMessageResponse response, string downloadPath)
{
FileHelper fileHelper = new FileHelper();
var finalPath = fileHelper.PrepareFileToDownload(response.FilesMetaData, downloadPath);
fileHelper.DownloadSecureFiles(response.FilesMetaData, downloadPath);
int fileFinish = 0;
int totalFile = response.FilesMetaData.Files.Count;
// The event for a file
fileHelper.DownloadFinish_event += (file) =>
{
// a file is finish
fileFinish++;
};
// all the file are finish
fileHelper.DownloadsFinish_event += (files) =>
{
// files are downloadedFiles
if (fileFinish != files.Count)
{
// an error has occur
}
else
{
// your files are downloaded and decrypted
}
};
}
/// <summary>
/// Print any messages received
/// </summary>
public void PrintReceivedMessage(GetMessageResponse messageResponse)
{
if (!string.IsNullOrEmpty(messageResponse.Content))
{
Console.WriteLine($"{messageResponse.SenderId}: {messageResponse.Content}{Environment.NewLine}");
}
}
public async Task <GetMessageResponse> GetMessageForApplication(string id, int amount, int since)
{
var queryString = new Dictionary <string, string>()
{
{ "amount", amount.ToString() },
{ "since", since.ToString() }
};
var requestUri = QueryHelpers.AddQueryString(appPath.Replace("NUM", id), queryString);
var request = new HttpRequestMessage(HttpMethod.Get, requestUri);
var httpclient = services.GetService <IHttpClientFactory>();
var client = httpclient.CreateClient("AdminAuth");
HttpResponseMessage result = await client.SendAsync(request);
if (result.IsSuccessStatusCode)
{
var parsedJson = JsonConvert.DeserializeObject <GetMessage>(await result.Content.ReadAsStringAsync());
GetMessageResponse messageModel = new GetMessageResponse(true, parsedJson);
return(messageModel);
}
else
{
var parsedJson = JsonConvert.DeserializeObject <RequestError>(await result.Content.ReadAsStringAsync());
GetMessageResponse clientModel = new GetMessageResponse(false, parsedJson);
return(clientModel);
}
}
public static void BuildResponse(IDictionary <string, IList <object> > getResult, int commandVersion, string requestStringId, IList serializedResponse, int commandId, Cache cache)
{
Util.KeyPackageBuilder.Cache = cache;
int numberOfChunks = 0;
int sequenceId = 1;
long requestId = Convert.ToInt64(requestStringId);
HashVector <string, ClusteredList <List <Message> > > resultInChunks = new HashVector <string, ClusteredList <List <Message> > >();
foreach (var pair in getResult)
{
var messageListChunks = Util.KeyPackageBuilder.GetMessages(pair.Value);
if (resultInChunks.ContainsKey(pair.Key))
{
ClusteredList <List <Message> > messageList = resultInChunks[pair.Key];
messageList.AddRange(messageListChunks);
}
else
{
resultInChunks.Add(pair.Key, messageListChunks);
}
numberOfChunks += messageListChunks.Count;
}
Response response = new Response();
response.requestId = requestId;
response.commandID = commandId;
response.responseType = Response.Type.GET_MESSAGE;
GetMessageResponse getMessageResponse = null;
if (resultInChunks.Count == 0)
{
getMessageResponse = new GetMessageResponse();
response.getMessageResponse = getMessageResponse;
serializedResponse.Add(Common.Util.ResponseHelper.SerializeResponse(response));
return;
}
getMessageResponse = new GetMessageResponse();
foreach (var pair in resultInChunks)
{
TopicMessages topicMessage = new TopicMessages();
topicMessage.topic = pair.Key;
for (int i = 0; i < pair.Value.Count; i++)
{
topicMessage.messageList.AddRange(pair.Value[i]);
}
getMessageResponse.topicMessages.Add(topicMessage);
}
response.getMessageResponse = getMessageResponse;
serializedResponse.Add(Common.Util.ResponseHelper.SerializeResponse(response));
}
public void ReadSecureExchangesMessage(string link, string password, string digit)
{
SecureExchangesMessage msg = MessageHelper.GetSecureExchangesMessageFromLink(link);
GetMessageResponse messageResponse = SecureExchangesSDK.Helpers.MessageHelper.GetMessage(new SecureExchangesSDK.Models.Args.GetMessageArgs(EndPointURI, TestSerialNumber, TestAPIUser, TestAPIPsw, msg.MessageID, msg.Cpart, msg.Sems, msg.NIv, msg.P2, password, msg.Pit, digit, msg.Sit));
if (messageResponse != null)
{
// this will be the un encrypted message
string confidentialMessage = messageResponse.Message;
// that will be the subject
string subject = messageResponse.Subject;
// Download the message file
DownloadMessageFile(messageResponse, Path.Combine(RootPath, "Download"));
}
}
public static GetMessageResponse GetMessages(string Mailbox)
{
if (Membership.GetUser() == null || !Membership.GetUser().IsApproved)
return new GetMessageResponse(false);
MessageManager messageMgr = new MessageManager();
GetMessageResponse response = new GetMessageResponse(true);
if(Mailbox != "New")
response.messages = messageMgr.GetMailbox(Membership.GetUser().UserName,Mailbox);
else
response.messages = messageMgr.GetUnreadInbox(Membership.GetUser().UserName);
response.NewCount = messageMgr.CountMessages(Membership.GetUser().UserName, "New");
response.InboxCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Inbox");
response.SentCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Sent");
response.TrashCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Trash");
messageMgr.Dispose();
return response;
}
public static GetMessageResponse SearchMessages(string term)
{
if (Membership.GetUser() == null || !Membership.GetUser().IsApproved)
{
return(new GetMessageResponse(false));
}
MessageManager messageMgr = new MessageManager();
GetMessageResponse response = new GetMessageResponse(true);
response.messages = messageMgr.Search(Membership.GetUser().UserName, term);
response.NewCount = messageMgr.CountMessages(Membership.GetUser().UserName, "New");
response.InboxCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Inbox");
response.SentCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Sent");
response.TrashCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Trash");
messageMgr.Dispose();
return(response);
}
public async Task <AuthenticatedUser> Authenticate(string username, string password)
{
try
{
var data = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("grant_type", "password"),
new KeyValuePair <string, string>("username", username),
new KeyValuePair <string, string>("password", password),
});
using (HttpResponseMessage response = await _apiClient.PostAsync("/Token", data))
{
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsAsync <AuthenticatedUser>();
return(result);
}
else
{
string message = GetMessageResponse.ErrorMessageFromResponse(response);
if (!string.IsNullOrEmpty(message))
{
Exception ex = new Exception(message);
// _logger.Error("Got exception", ex);
throw ex;
}
Exception exc = new Exception(response.ReasonPhrase);
// _logger.Error("Got exception", exc);
throw exc;
}
}
}
catch (Exception ex)
{
// _logger.Error("Got exception", ex);
throw;
}
}
public async Task <bool> Register(RegisterModel registerModel)
{
using (HttpResponseMessage response = await _apiClient.PostAsJsonAsync("/api/Account/register", registerModel))
{
if (response.IsSuccessStatusCode)
{
return(response.IsSuccessStatusCode);
}
else
{
string message = GetMessageResponse.ErrorMessageFromResponse(response);
if (!string.IsNullOrEmpty(message))
{
Exception ex = new Exception(message);
//_logger.Error("Got exception", ex);
throw ex;
}
Exception exc = new Exception(response.ReasonPhrase);
// _logger.Error("Got exception", exc);
throw exc;
}
}
}
public static GetMessageResponse SearchMessages(string term)
{
if (Membership.GetUser() == null || !Membership.GetUser().IsApproved)
return new GetMessageResponse(false);
MessageManager messageMgr = new MessageManager();
GetMessageResponse response = new GetMessageResponse(true);
response.messages = messageMgr.Search(Membership.GetUser().UserName,term);
response.NewCount = messageMgr.CountMessages(Membership.GetUser().UserName, "New");
response.InboxCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Inbox");
response.SentCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Sent");
response.TrashCount = messageMgr.CountMessages(Membership.GetUser().UserName, "Trash");
messageMgr.Dispose();
return response;
}
private static void OnGetMessagesSuccessCallback(string json)
{
GetMessageResponse messages = NativeUiJsonDeserializer.DeserializeGetMessages(json);
SaveContext.SaveCampaigns(messages.campaigns);
SaveContext.SaveLocalState(messages.localState);
SaveContext.SavePropertyId(messages.propertyId);
var gdprCamp = messages.GetGdprCampaign();
var ccpaCamp = messages.GetCcpaCampaign();
if (gdprCamp != null)
{
if (gdprCamp?.message == null || gdprCamp.ui == null || gdprCamp.ui.Count == 0)
{
if (gdprCamp.userConsent == null)
{
UnityEngine.Debug.LogError("UserConsent is NULL");
}
else
{
gdprUserConsent = new PostConsentUserConsent()
{
TCData = gdprCamp.userConsent.TCData,
grants = gdprCamp.userConsent.grants,
// specialFeatures = gdprCamp.userConsent.,
// legIntCategories = gdprCamp.userConsent.,
// acceptedVendors = gdprCamp.userConsent.,
// acceptedCategories = gdprCamp.userConsent.,
euconsent = gdprCamp.userConsent.euconsent,
addtlConsent = gdprCamp.userConsent.addtlConsent,
dateCreated = gdprCamp.userConsent.dateCreated,
consentedToAll = gdprCamp.userConsent.consentedToAll.GetValueOrDefault(false)
};
SaveContext.SaveGdprUserConsent(gdprUserConsent);
CmpCampaignPopupQueue.DequeueCampaignId();
isGdprConsented = true;
}
}
else
{
GdprMessage gdpr = gdprCamp?.message;
shortCategories = gdpr?.categories;
popupBgColors = gdprCamp?.popupBgColors;
gdprElements = gdprCamp?.ui;
}
}
if (ccpaCamp != null)
{
if (ccpaCamp.userConsent != null && (!ccpaCamp.userConsent.newUser || ccpaCamp.userConsent.rejectedAll || ccpaCamp.userConsent.status.Equals("consentedAll")))
{
ccpaUserConsent = new PostConsentUserConsent()
{
uspstring = ccpaCamp.userConsent.uspstring,
status = ccpaCamp.userConsent.status,
rejectedVendors = ccpaCamp.userConsent.rejectedVendors.ToArray(),
rejectedCategories = ccpaCamp.userConsent.rejectedCategories.ToArray(),
signedLspa = ccpaCamp.userConsent.signedLspa,
rejectedAll = ccpaCamp.userConsent.rejectedAll,
};
SaveContext.SaveCcpaUserConsent(ccpaUserConsent);
CmpCampaignPopupQueue.DequeueCampaignId();
isCcpaConsented = true;
}
else if (ccpaCamp?.message != null || ccpaCamp.ui != null || ccpaCamp.ui.Count != 0)
{
BaseMessage ccpa = ccpaCamp?.message;
popupBgColors = ccpaCamp.popupBgColors;
ccpaElements = ccpaCamp.ui;
// shortCategories ??
}
else if (ccpaCamp.userConsent == null)
{
UnityEngine.Debug.LogError("UserConsent is NULL");
}
}
isInitialized = true;
if (!CmpCampaignPopupQueue.IsCampaignAvailable)
{
CmpPopupDestroyer.DestroyAllHelperGO();
}
}
public static GetMessageResponse DeserializeGetMessages(string json)
{
// TODO:
// InvalidOperationException
// System.Text.Json.JsonReaderException (JsonException)
GetMessageResponse result = null;
using (JsonDocument document = JsonDocument.Parse(json))
{
var root = document.RootElement;
// if (root.ValueKind == JsonValueKind.Null || root.ValueKind != JsonValueKind.Object)
result = JsonSerializer.Deserialize <GetMessageResponse>(root.GetRawText());
//proper deserialization of campaigns depending of the type
if (result.campaigns.Count > 0)
{
List <BaseGetMessagesCampaign> campaigns = new List <BaseGetMessagesCampaign>();
root.TryGetProperty("campaigns", out JsonElement collection);
var coll = collection.EnumerateArray().ToArray();
for (int i = 0; i < coll.Length; i++)
{
switch (result.campaigns[i].type)
{
case "GDPR":
GdprGetMessagesCampaign gdprCamp = DeserializeGetMessagesCampaign <GdprGetMessagesCampaign>(coll[i]);
if (coll[i].TryGetProperty("message", out JsonElement gdprMsg) &&
gdprMsg.TryGetProperty("message_json", out JsonElement gdprUi))
{
Dictionary <string, string> popupBgColors = new Dictionary <string, string>();
Dictionary <string, List <CmpUiElementModel> > ui = DeserializeNativePm(gdprUi.GetRawText(), ref popupBgColors);
gdprCamp.ui = ui;
gdprCamp.popupBgColors = popupBgColors;
}
campaigns.Add(gdprCamp);
break;
case "CCPA":
CcpaGetMessagesCampaign ccpaCamp = DeserializeGetMessagesCampaign <CcpaGetMessagesCampaign>(coll[i]);
if (coll[i].TryGetProperty("message", out JsonElement ccpaMsg) &&
ccpaMsg.TryGetProperty("message_json", out JsonElement ccpaUi))
{
Dictionary <string, string> popupBgColors = new Dictionary <string, string>();
Dictionary <string, List <CmpUiElementModel> > ui = DeserializeNativePm(ccpaUi.GetRawText(), ref popupBgColors);
ccpaCamp.ui = ui;
ccpaCamp.popupBgColors = popupBgColors;
}
campaigns.Add(ccpaCamp);
break;
case "ios14":
campaigns.Add(DeserializeGetMessagesCampaign <Ios14GetMessagesCampaign>(coll[i]));
break;
default:
//wtf
break;
}
}
result.campaigns = campaigns;
}
}
return(result);
}
public static void BuildResponse(IDictionary <string, IList <object> > getResult, int commandVersion, string requestStringId, IList serializedResponse, int commandId, long requestID, NCache nCache, string _clientID, ClientManager clientManager)
{
Util.KeyPackageBuilder.Cache = nCache.Cache;
int numberOfChunks = 0;
int sequenceId = 1;
long requestId = Convert.ToInt64(requestStringId);
HashVector <string, ClusteredList <List <Message> > > resultInChunks = new HashVector <string, ClusteredList <List <Message> > >();
foreach (var pair in getResult)
{
var messageListChunks = Util.KeyPackageBuilder.GetMessages(pair.Value, nCache, _clientID);
if (resultInChunks.ContainsKey(pair.Key))
{
ClusteredList <List <Message> > messageList = resultInChunks[pair.Key];
messageList.AddRange(messageListChunks);
}
else
{
resultInChunks.Add(pair.Key, messageListChunks);
}
numberOfChunks += messageListChunks.Count;
}
GetMessageResponse getMessageResponse = new GetMessageResponse();
if (clientManager.ClientVersion >= 5000)
{
Common.Util.ResponseHelper.SetResponse(getMessageResponse, requestID, commandId);
if (resultInChunks.Count == 0)
{
serializedResponse.Add(Common.Util.ResponseHelper.SerializeResponse(getMessageResponse, Common.Protobuf.Response.Type.GET_MESSAGE));
return;
}
foreach (var pair in resultInChunks)
{
//response.sequenceId = sequenceId++;
TopicMessages topicMessage = new TopicMessages();
topicMessage.topic = pair.Key;
for (int i = 0; i < pair.Value.Count; i++)
{
topicMessage.messageList.AddRange(pair.Value[i]);
}
getMessageResponse.topicMessages.Add(topicMessage);
}
serializedResponse.Add(Common.Util.ResponseHelper.SerializeResponse(getMessageResponse, Common.Protobuf.Response.Type.GET_MESSAGE));
}
else
{
Response response = new Response();
Common.Util.ResponseHelper.SetResponse(response, requestID, commandId, Common.Protobuf.Response.Type.GET_MESSAGE);
if (resultInChunks.Count == 0)
{
response.getMessageResponse = getMessageResponse;
serializedResponse.Add(Alachisoft.NCache.Common.Util.ResponseHelper.SerializeResponse(response));
return;
}
foreach (var pair in resultInChunks)
{
//response.sequenceId = sequenceId++;
TopicMessages topicMessage = new TopicMessages();
topicMessage.topic = pair.Key;
for (int i = 0; i < pair.Value.Count; i++)
{
topicMessage.messageList.AddRange(pair.Value[i]);
}
getMessageResponse.topicMessages.Add(topicMessage);
}
response.getMessageResponse = getMessageResponse;
serializedResponse.Add(Alachisoft.NCache.Common.Util.ResponseHelper.SerializeResponse(response));
}
}
private async void RetrieveAllMessages()
{
if (string.IsNullOrEmpty(txtIPAddress.Text))
{
MessageBox.Show("Please enter an IP address", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
txtIPAddress.Focus();
return;
}
try
{
btnRetrieveAllMessages.Enabled = false;
/*
* HttpClientHandler handler = new HttpClientHandler();
* if (!string.IsNullOrEmpty(txtUserName.Text) && !string.IsNullOrEmpty(txtPassword.Text))
* {
* handler.UseDefaultCredentials = true;
* handler.Credentials = new NetworkCredential(txtUserName.Text, txtPassword.Text);
* }
*/
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))));
}
HttpResponseMessage response = await client.GetAsync(MessagesUrlPath);
if (response.IsSuccessStatusCode)
{
GetMessageResponse result = await response.Content.ReadAsAsync <GetMessageResponse>();
if (result.IsSuccessful)
{
txtOutput.Clear();
foreach (DeviceMessage msg in result.Messages)
{
AddToOutput(msg.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
{
btnRetrieveAllMessages.Enabled = true;
}
}
public void Execute(OnHandleRequest pipelineEvent)
{
Guard.AgainstNull(pipelineEvent, nameof(pipelineEvent));
var state = pipelineEvent.Pipeline.State;
var transportFrame = state.Get <TransportFrame>(StateKeys.TransportFrame);
var message = state.Get <object>(StateKeys.Message);
Response response;
var queue = _queueManager.GetQueue(_configuration.GetQueue(transportFrame.QueueName).Uri);
switch (message)
{
case AcknowledgeRequest request:
{
queue.Acknowledge(request.AcknowledgementToken);
response = new Response();
break;
}
case EnqueueRequest request:
{
queue.Enqueue(request.TransportMessage, new MemoryStream(request.StreamBytes));
response = new Response();
break;
}
case GetMessageRequest _:
{
var receivedMessage = queue.GetMessage();
response = new GetMessageResponse
{
AcknowledgementToken = receivedMessage?.AcknowledgementToken,
StreamBytes = receivedMessage?.Stream.ToBytes()
};
receivedMessage?.Stream.Dispose();
break;
}
case IsEmptyRequest _:
{
response = new IsEmptyResponse {
Result = queue.IsEmpty()
};
break;
}
case ReleaseRequest request:
{
queue.Release(request.AcknowledgementToken);
response = new Response();
break;
}
default:
{
throw new ApplicationException(string.Format(NetMQ.Resources.UnknownRequestType,
message.GetType().FullName));
}
}
var type = response.GetType();
state.Replace(StateKeys.Response, response);
state.Replace(StateKeys.TransportFrame, new TransportFrame
{
QueueName = transportFrame.QueueName,
AssemblyQualifiedName = type.AssemblyQualifiedName,
MessageType = type.FullName
});
}
private async void RetrieveNewMessages()
{
// check message syntax......
if (string.IsNullOrEmpty(txtIPAddress.Text))
{
//MessageBox.Show("Please enter an IP address", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
txtIPAddress.Focus();
return;
}
try
{
btnRefresh.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))));
}
HttpResponseMessage response = await client.GetAsync(MessagesUrlPath + "?status=0");
if (response.IsSuccessStatusCode)
{
GetMessageResponse result = await response.Content.ReadAsAsync <GetMessageResponse>();
if (result.IsSuccessful)
{
// txtOutput.Text = "";
//
// MyMessage myMessage = new MyMessage();
List <DeviceMessage> mList = new List <DeviceMessage>();
int uid = 0;
List <BLL.tb_log> l_list = new List <BLL.tb_log>();
foreach (DeviceMessage msg in result.Messages)
{
uid = isAuthorised(msg.Number);
if (uid > 0)
{
BLL.tb_log log = new BLL.tb_log();
log.user_id = uid;
log.sender_mobile_number = msg.Number;
if (msg.Number.Equals(server_number) || msg.Number.Equals(server_number2) || msg.Number.Equals(server_number155))
{
log.isFromServer = true;
}
else
{
log.isFromServer = false;
}
log.msg_text = msg.Message;
log.isCommandSent = false;
log.isUserReplied = false;
mList.Add(msg);
log.SaveLog(log);
markMessageAsRead(msg.Id);
}
}
dgViewMessage.DataSource = mList;
string t = "No Message from Regd Users...";
if (mList.Count < 1)
{
txtLogs.Text += DateTime.Now + "-" + (t + "\r\n");
}
}
else
{
this.dgViewMessage.DataSource = null;
this.dgViewMessage.Rows.Clear();
txtLogs.Text += DateTime.Now + "-" + (result.Description + "\r\n");
// txtLogs.Text = result.Description;
// MessageBox.Show(result.Description, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
txtLogs.Text += DateTime.Now + "-" + (response.ToString() + "\r\n");
//
// MessageBox.Show(response.ToString(), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
catch (Exception ex)
{
txtLogs.Text += DateTime.Now + "-" + (ex.Message + "\r\n");
// MessageBox.Show(ex.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
btnRefresh.Enabled = true;
}
}
