/// <summary>
/// Fills the object with values from the data byte.
/// </summary>
/// <param name="b">The byte value.</param>
protected override void FromByte(byte b)
{
OutgoingMessageType outgoingMessageType = OutgoingMessageType.SmsSubmit;
if ((b & 1) > 0)
{
outgoingMessageType = OutgoingMessageType.SmsSubmit;
}
if (outgoingMessageType == OutgoingMessageType.SmsSubmit)
{
this.rejectDuplicates = (b & 4) > 0;
this.validityPeriodFormat = ValidityPeriodFormat.Unspecified;
if ((b & 24) > 0)
{
this.validityPeriodFormat = ValidityPeriodFormat.Absolute;
}
if ((b & 16) > 0)
{
this.validityPeriodFormat = ValidityPeriodFormat.Relative;
}
if ((b & 8) > 0)
{
this.validityPeriodFormat = ValidityPeriodFormat.Enhanced;
}
this.requestStatusReport = (b & 32) > 0;
this.userDataHeaderPresent = (b & 64) > 0;
this.replyPathExists = (b & 128) > 0;
return;
}
else
{
throw new ArgumentException("Not an SMS-SUBMIT message.");
}
}
/// <summary>
/// Decodes an outgoing SMS PDU stream.
/// </summary>
/// <param name="pdu">The PDU string to decode</param>
/// <param name="includesSmscData">Specify true if the PDU data contains an SMSC header, otherwise false.</param>
/// <param name="actualLength">The length of the PDU in bytes, not including the SMSC header.</param>
/// <returns>An <see cref="T:GsmComm.PduConverter.OutgoingSmsPdu" /> object representing the decoded message.</returns>
public static OutgoingSmsPdu Decode(string pdu, bool includesSmscData, int actualLength)
{
if (pdu != string.Empty)
{
int num = 0;
if (includesSmscData)
{
int num1 = num;
num = num1 + 1;
byte num2 = BcdWorker.GetByte(pdu, num1);
if (num2 > 0)
{
num = num + num2;
}
}
int num3 = num;
OutgoingMessageType messageType = OutgoingSmsPdu.GetMessageType(BcdWorker.GetByte(pdu, num3));
OutgoingMessageType outgoingMessageType = messageType;
if (outgoingMessageType != OutgoingMessageType.SmsSubmit)
{
throw new NotSupportedException(string.Concat("Message type ", messageType.ToString(), " recognized, but not supported by the SMS decoder."));
}
else
{
return(new SmsSubmitPdu(pdu, includesSmscData, actualLength));
}
}
else
{
throw new ArgumentException("pdu must not be an empty string.");
}
}
/// <summary>
/// Handles the SelectedIndexChanged event of the cboMessageType control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void cboMessageType_SelectedIndexChanged(object sender, EventArgs e)
{
OutgoingMessageType messageType =(OutgoingMessageType)StringEnum.Parse(typeof(OutgoingMessageType), cboMessageType.Text);
if (messageType == OutgoingMessageType.SMS)
{
pnlMessage.Visible = true;
pnlWapPush.Visible = false;
}
else if (messageType == OutgoingMessageType.WAPPush)
{
pnlMessage.Visible = false;
pnlWapPush.Visible = true;
}
}
/// <summary>
/// Presets the message details.
/// </summary>
/// <param name="msg">The MSG.</param>
private void PresetMessageDetails(IActiveRecord rec)
{
if (rec.GetType() == typeof(IncomingMessage))
{
IncomingMessage msg = rec as IncomingMessage;
txtMessageContent.Text = msg.Message;
pnlMessage.Visible = true;
pnlWapPush.Visible = false;
}
else if (rec.GetType() == typeof(OutgoingMessage))
{
OutgoingMessage msg = rec as OutgoingMessage;
OutgoingMessageType messageType = (OutgoingMessageType)StringEnum.Parse(typeof(OutgoingMessageType), msg.MessageType);
if (messageType == OutgoingMessageType.SMS)
{
txtMessageContent.Text = msg.Message;
pnlMessage.Visible = true;
pnlWapPush.Visible = false;
}
else if (messageType == OutgoingMessageType.WAPPush)
{
cboMessageType.Text = msg.MessageType;
txtWapPushMessage.Text = msg.Message;
txtWapPushUrl.Text = msg.WapUrl;
cboWapPushSignal.Text = msg.WapSignal;
if (msg.WapCreateDate.HasValue)
{
chkWapPushCreated.Checked = true;
dtpWapPushCreated.Value = msg.WapCreateDate.Value;
}
if (msg.WapExpiryDate.HasValue)
{
chkWapPushExpiry.Checked = true;
dtpWapPushExpiryDate.Value = msg.WapExpiryDate.Value;
}
pnlMessage.Visible = false;
pnlWapPush.Visible = true;
}
}
}
/// <summary>
/// Handles the SelectedIndexChanged event of the lvwMessages control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void lvwMessages_SelectedIndexChanged(object sender, EventArgs e)
{
OutgoingMessage selectedMessage = (OutgoingMessage)lvwMessages.SelectedObject;
if (selectedMessage != null)
{
OutgoingMessageType messageType = (OutgoingMessageType)StringEnum.Parse(typeof(OutgoingMessageType), selectedMessage.MessageType);
lblTo.Text = selectedMessage.Recipient;
lblStatus.Text = selectedMessage.Status;
lblID.Text = selectedMessage.Id;
lblFrom.Text = selectedMessage.Originator;
lblPriority.Text = selectedMessage.Priority;
lblMessageType.Text = selectedMessage.MessageType;
lblGatewayID.Text = selectedMessage.GatewayId;
lblLastUpdate.Text = selectedMessage.LastUpdate.ToString();
rtbContent.Text = selectedMessage.Message;
if (messageType == OutgoingMessageType.SMS)
{
lblURL.Text = string.Empty;
}
else if (messageType == OutgoingMessageType.WAPPush)
{
lblURL.Text = selectedMessage.WapUrl;
}
if (selectedMessage.ScheduledDate.HasValue)
{
lblScheduled.Text = selectedMessage.ScheduledDate.ToString();
}
else
{
lblScheduled.Text = Resources.MsgNow;
}
}
}
public static bool TryDeserializeOutgoing(string message, out OutgoingMessageType messageType, out ArraySegment <JsonElement> args) => TryDeserialize(message, out messageType, out args);
public static string Serialize(OutgoingMessageType messageType, params object[] args) => Serialize(messageType.ToString(), args);
/// <summary>
/// Saves the changes.
/// </summary>
/// <returns></returns>
private bool SaveChanges()
{
OutgoingMessageType messageType =(OutgoingMessageType)StringEnum.Parse(typeof(OutgoingMessageType), cboMessageType.Text);
// Validate recipients are not empty
if (!FormHelper.ValidateNotEmpty(txtTo, Resources.MsgRecipientsRequired))
{
return false;
}
if (messageType == OutgoingMessageType.SMS)
{
// Validate message is not empty
if (!FormHelper.ValidateNotEmpty(txtMessageContent, Resources.MsgContentRequired))
{
return false;
}
}
else if (messageType == OutgoingMessageType.WAPPush)
{
// Validate URL
if (!FormHelper.ValidateNotEmpty(txtWapPushUrl, Resources.MsgURLRequired))
{
return false;
}
// Validate message is not empty
if (!FormHelper.ValidateNotEmpty(txtWapPushMessage, Resources.MsgContentRequired))
{
return false;
}
}
// The To list can be separated by comma or semicolon
string[] toList = txtTo.Text.Split(GuiHelper.SupportedSeparators, StringSplitOptions.RemoveEmptyEntries);
try
{
string groupId = GatewayHelper.GenerateUniqueIdentifier();
using (SharedDbConnectionScope sharedConnectionScope = new SharedDbConnectionScope())
{
using (TransactionScope ts = new TransactionScope())
{
try
{
foreach (string to in toList)
{
OutgoingMessage message = new OutgoingMessage();
message.Id = GatewayHelper.GenerateUniqueIdentifier();
message.GatewayId = cboChannel.Text;
message.Recipient = to.Trim();
message.Originator = txtFrom.Text;
message.MessageType = cboMessageType.Text;
message.MessageFormat = cboMessageFormat.Text;
message.LastUpdate = DateTime.Now;
message.CreateDate = message.LastUpdate;
message.SrcPort = Convert.ToInt32(npdSourcePort.Value);
message.DestPort = Convert.ToInt32(npdDestinationPort.Value);
message.Status = StringEnum.GetStringValue(MessageStatus.Pending);
message.MessageClass = cboMessageClass.Text;
message.Priority = cboPriority.Text;
message.StatusReport = cboStatusReport.Text;
message.Quantity = Convert.ToInt32(npdQuantity.Value);
message.GroupId = groupId;
if (chkScheduleSendTime.Checked)
message.ScheduledDate = dtpScheduleTime.Value;
if (messageType == OutgoingMessageType.SMS)
{
message.Message = txtMessageContent.Text;
}
else if (messageType == OutgoingMessageType.WAPPush)
{
message.WapUrl = txtWapPushUrl.Text;
message.WapSignal = cboWapPushSignal.Text;
message.Message = txtWapPushMessage.Text;
if (chkWapPushCreated.Checked)
message.WapCreateDate = dtpWapPushCreated.Value;
if (chkWapPushExpiry.Checked)
message.WapExpiryDate = dtpWapPushExpiryDate.Value;
}
message.Save();
}
}
finally
{
try
{
ts.Complete();
}
catch (Exception) { }
// Refresh the message view
RefreshMessageView(ViewAction.RefreshOutbox);
}
}
}
}
catch (Exception ex)
{
FormHelper.ShowError(ex.Message);
return false;
}
// Show successful save message
if (toList.Count() == 1)
{
FormHelper.ShowInfo(Resources.MsgSingleMessageCreated);
}
else
{
FormHelper.ShowInfo(string.Format(Resources.MsgMultipleMessagesCreated, toList.Count()));
}
return true;
}
/// <summary>
/// Handles the Load event of the frmMessageDetails control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void frmMessageDetails_Load(object sender, EventArgs e)
{
if (Message == null)
{
FormHelper.ShowError(Resources.MsgNoMessageToDisplay);
return;
}
if (this.Message.GetType() == typeof(IncomingMessage))
{
IncomingMessage msg = this.Message as IncomingMessage;
txtID.Text = msg.Id;
txtType.Text = msg.MessageType;
txtLastUpdate.Text = msg.LastUpdate.ToString();
txtSent.Text = string.Empty;
txtReceived.Text = msg.ReceivedDate.ToString();
txtScheduled.Text = string.Empty;
txtChannel.Text = msg.GatewayId;
txtReference.Text = msg.Indexes;
txtStatus.Text = msg.Status;
txtFrom.Text = msg.Originator;
txtTo.Text = string.Empty;
txtFormat.Text = string.Empty;
txtPriority.Text = string.Empty;
rtbBody.Text = msg.Message;
grpSms.Visible = true;
grpWapPush.Visible = false;
tsbMessageReply.Enabled = true;
}
else if (this.Message.GetType() == typeof(OutgoingMessage))
{
OutgoingMessage msg = this.Message as OutgoingMessage;
txtID.Text = msg.Id;
txtType.Text = msg.MessageType;
txtLastUpdate.Text = msg.LastUpdate.ToString();
txtSent.Text = msg.SentDate.ToString();
txtReceived.Text = string.Empty;
if (msg.ScheduledDate.HasValue)
{
txtScheduled.Text = msg.ScheduledDate.ToString();
}
else
{
txtScheduled.Text = Resources.MsgNow;
}
txtChannel.Text = msg.GatewayId;
txtReference.Text = msg.RefNo;
txtStatus.Text = msg.Status;
txtFrom.Text = msg.Originator;
txtTo.Text = msg.Recipient;
txtFormat.Text = msg.MessageFormat;
txtPriority.Text = msg.Priority;
OutgoingMessageType messageType = (OutgoingMessageType)StringEnum.Parse(typeof(OutgoingMessageType), msg.MessageType);
if (messageType == OutgoingMessageType.SMS)
{
rtbBody.Text = msg.Message;
grpSms.Visible = true;
grpWapPush.Visible = false;
}
else if (messageType == OutgoingMessageType.WAPPush)
{
txtWapPushMessage.Text = msg.Message;
txtWapPushUrl.Text = msg.WapUrl;
txtCreated.Text = msg.WapCreateDate.ToString();
txtExpiry.Text = msg.WapExpiryDate.ToString();
txtSignal.Text = msg.WapSignal;
grpSms.Visible = false;
grpWapPush.Visible = true;
}
tsbMessageReply.Enabled = false;
}
}
/// <summary>
/// Does the work.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public override void DoWork(object sender, ElapsedEventArgs e)
{
if (messageGatewayService.Gateways.Count() == 0)
{
return;
}
if (log.IsDebugEnabled)
{
log.Debug("Checking outgoing message");
}
IOrderedQueryable <OutgoingMessage> messages = OutgoingMessage.All().Where(msg => msg.Status != StringEnum.GetStringValue(MessageStatus.Archived) &&
msg.Status != StringEnum.GetStringValue(MessageStatus.Failed) &&
msg.Status != StringEnum.GetStringValue(MessageStatus.Sending) &&
msg.Status != StringEnum.GetStringValue(MessageStatus.Sent) &&
(
msg.ScheduledDate == null ||
msg.ScheduledDate <= DateTime.Now
)).OrderBy(msg => msg.LastUpdate);
// Send out messages
foreach (OutgoingMessage message in messages)
{
List <IMessage> outgoingMessages = new List <IMessage>(messages.Count());
OutgoingMessageType messageType = (OutgoingMessageType)StringEnum.Parse(typeof(OutgoingMessageType), message.MessageType);
if (messageType == OutgoingMessageType.SMS)
{
// Get the target routed gateway
Sms sms = Sms.NewInstance();
sms.Identifier = message.Id;
sms.DestinationAddress = message.Recipient;
sms.Content = message.Message;
MessageFormat format = (MessageFormat)StringEnum.Parse(typeof(MessageFormat), message.MessageFormat);
sms.DataCodingScheme = EnumMatcher.MessageCoding[format];
sms.ValidityPeriod = MessageValidPeriod.OneDay;
MessageStatusReport statusReport = (MessageStatusReport)StringEnum.Parse(typeof(MessageStatusReport), message.StatusReport);
if (statusReport == MessageStatusReport.StatusReport)
{
sms.StatusReportRequest = MessageStatusReportRequest.SmsReportRequest;
}
else if (statusReport == MessageStatusReport.NoStatusReport)
{
sms.StatusReportRequest = MessageStatusReportRequest.NoSmsReportRequest;
}
sms.DcsMessageClass = EnumMatcher.MessageClass[message.MessageClass];
sms.QueuePriority = EnumMatcher.MessagePriority[message.Priority];
IGateway gateway = messageGatewayService.Router.GetRoute(sms);
GatewayConfig gatewayConfig = GatewayConfig.SingleOrDefault(g => g.Id == gateway.Id);
if (gatewayConfig != null)
{
// Message validity period
if (!string.IsNullOrEmpty(gatewayConfig.MessageValidity))
{
sms.ValidityPeriod = EnumMatcher.ValidityPeriod[gatewayConfig.MessageValidity];
}
// Status report
if (statusReport == MessageStatusReport.FollowChannel)
{
if (gatewayConfig.RequestStatusReport.Value)
{
sms.StatusReportRequest = MessageStatusReportRequest.SmsReportRequest;
}
else
{
sms.StatusReportRequest = MessageStatusReportRequest.NoSmsReportRequest;
}
}
if (gatewayConfig.UseSimSmsc.HasValue && !gatewayConfig.UseSimSmsc.Value && !string.IsNullOrEmpty(gatewayConfig.Smsc))
{
sms.ServiceCenterNumber = gatewayConfig.Smsc;
}
}
outgoingMessages.Add(sms);
// Update status to "Sending"
message.Status = StringEnum.GetStringValue(MessageStatus.Sending);
message.LastUpdate = DateTime.Now;
message.Update();
}
else if (messageType == OutgoingMessageType.WAPPush)
{
Wappush wappush = Wappush.NewInstance(message.Recipient, message.WapUrl, message.Message);
ServiceIndicationAction signal;
if (EnumMatcher.ServiceIndication.TryGetValue(message.WapSignal, out signal))
{
wappush.Signal = signal;
}
wappush.CreateDate = message.WapCreateDate.Value;
wappush.ExpireDate = message.WapExpiryDate.Value;
MessageStatusReport statusReport = (MessageStatusReport)StringEnum.Parse(typeof(MessageStatusReport), message.StatusReport);
if (statusReport == MessageStatusReport.StatusReport)
{
wappush.StatusReportRequest = MessageStatusReportRequest.SmsReportRequest;
}
else if (statusReport == MessageStatusReport.NoStatusReport)
{
wappush.StatusReportRequest = MessageStatusReportRequest.NoSmsReportRequest;
}
wappush.DcsMessageClass = EnumMatcher.MessageClass[message.MessageClass];
wappush.QueuePriority = EnumMatcher.MessagePriority[message.Priority];
IGateway gateway = messageGatewayService.Router.GetRoute(wappush);
GatewayConfig gatewayConfig = GatewayConfig.SingleOrDefault(g => g.Id == gateway.Id);
if (gatewayConfig != null)
{
// Message validity period
if (!string.IsNullOrEmpty(gatewayConfig.MessageValidity))
{
wappush.ValidityPeriod = EnumMatcher.ValidityPeriod[gatewayConfig.MessageValidity];
}
// Status report
if (statusReport == MessageStatusReport.FollowChannel)
{
if (gatewayConfig.RequestStatusReport.Value)
{
wappush.StatusReportRequest = MessageStatusReportRequest.SmsReportRequest;
}
else
{
wappush.StatusReportRequest = MessageStatusReportRequest.NoSmsReportRequest;
}
}
}
outgoingMessages.Add(wappush);
// Update status to "Sending"
message.Status = StringEnum.GetStringValue(MessageStatus.Sending);
message.LastUpdate = DateTime.Now;
message.Update();
}
int count = messageGatewayService.SendMessages(outgoingMessages);
log.Debug(string.Format("Messages are queued for sending. Count of number of messages is [{0}]", count));
}
}
