public virtual MessageContent CreateMessageContentFromReader(IDataReader reader)
{
MessageContent item = new MessageContent();
try
{
if (!reader.IsDBNull(reader.GetOrdinal("MessageContentID"))) item.MessageContentID = (int)reader["MessageContentID"];
if (!reader.IsDBNull(reader.GetOrdinal("ContentTemplateID"))) item.ContentTemplateID = (int)reader["ContentTemplateID"];
if (!reader.IsDBNull(reader.GetOrdinal("ServiceTypeID"))) item.ServiceTypeID = (int)reader["ServiceTypeID"];
if (!reader.IsDBNull(reader.GetOrdinal("Sender"))) item.Sender = (string)reader["Sender"];
if (!reader.IsDBNull(reader.GetOrdinal("Receiver"))) item.Receiver = (string)reader["Receiver"];
if (!reader.IsDBNull(reader.GetOrdinal("Subject"))) item.Subject = (string)reader["Subject"];
if (!reader.IsDBNull(reader.GetOrdinal("BodyContentType"))) item.BodyContentType = (string)reader["BodyContentType"];
if (!reader.IsDBNull(reader.GetOrdinal("BodyEncoding"))) item.BodyEncoding = (string)reader["BodyEncoding"];
if (!reader.IsDBNull(reader.GetOrdinal("BodyMessage"))) item.BodyMessage = (string)reader["BodyMessage"];
if (!reader.IsDBNull(reader.GetOrdinal("CreatedDate"))) item.CreatedDate = (DateTime)reader["CreatedDate"];
if (!reader.IsDBNull(reader.GetOrdinal("ModifiedDate"))) item.ModifiedDate = (DateTime)reader["ModifiedDate"];
if (!reader.IsDBNull(reader.GetOrdinal("Status"))) item.Status = (Int32)reader["Status"];
if (!reader.IsDBNull(reader.GetOrdinal("ServiceID"))) item.ServiceID = (string)reader["ServiceID"];
if (!reader.IsDBNull(reader.GetOrdinal("CommandCode"))) item.CommandCode = (string)reader["CommandCode"];
if (!reader.IsDBNull(reader.GetOrdinal("Request"))) item.Request = (string)reader["Request"];
if (!reader.IsDBNull(reader.GetOrdinal("MoID"))) item.MoID = (string)reader["MoID"];
if (!reader.IsDBNull(reader.GetOrdinal("ChargeYN"))) item.ChargeYN = (string)reader["ChargeYN"];
if (!reader.IsDBNull(reader.GetOrdinal("TotalMessages"))) item.TotalMessages = (short)reader["TotalMessages"];
}
catch (Exception ex)
{
// log this exception
log4net.Util.LogLog.Error(ex.Message, ex);
// wrap it and rethrow
throw new ApplicationException(SR.DataAccessCreateMessageContentFromReaderException, ex);
}
return item;
}
protected void Send_Click(object sender, EventArgs e)
{
try
{
MessageContent messageContent = new MessageContent();
if (String.IsNullOrEmpty(receiverTextBox.Text) || String.IsNullOrEmpty(ContentTextBox.Text))
{
statusLabel.InnerText = "Vui lòng điền đầy đủ thông tin";
return;
}
messageContent.BodyContentType = "PlainText";
messageContent.BodyEncoding = "UTF-8";
messageContent.BodyMessage = ContentTextBox.Text.Trim();
messageContent.Receiver = receiverTextBox.Text.Trim();
messageContent.ServiceTypeID = 2;
SendSMS sendSMS = new SendSMS();
sendSMS.UserName = ApplicationHelper.SmsUserName;
sendSMS.Password = ApplicationHelper.SmsPassword;
sendSMS.Send(messageContent);
statusLabel.InnerText = "Gửi thành công";
}
catch (Exception ex)
{
statusLabel.InnerText = "Không thể kết nối tới server SMS";
}
}
private void LoadModify()
{
messageContent = MessageContentService.GetMessageContent(this.messageContentID);
if (messageContent != null)
{
this.LoadTemplateType.SelectedValue = Convert.ToString(messageContent.ContentTemplateID);
this.LoadServiceType.SelectedValue = Convert.ToString(messageContent.ServiceTypeID);
this.InputSender.Value = messageContent.Sender;
this.InputReceiver.Value = messageContent.Receiver;
this.inputSuject.Value = messageContent.Subject;
this.InputBodyContentType.Value = messageContent.BodyContentType;
this.InputBodyEncoding.Value = messageContent.BodyEncoding;
this.InputBodyMessager.Value = messageContent.BodyMessage;
}
}
/// <summary>
/// Versendet eine Nachricht
/// </summary>
public static async Task <Message> SendMessage(String toGuid, MessageContent content)
{
Message message = new Message
{
ToGuid = toGuid,
FromGuid = DataContext.Instance.Iam.UserGuid,
Content = content,
DateTime = DateTime.Now,
MessageGuid = Guid.NewGuid().ToString(),
From = DataContext.Instance.Iam,
State = MessageState.None
};
await apiClientService.PostMessage(message);
return(message);
}
public static void SaveMessageContentConfig(MessageContent config)
{
FileStream fileStream = new FileStream(string.Concat(EmailCore.WorkDirectory, "\\Data\\MessageContent.xml"), FileMode.Create);
try
{
(new XmlSerializer(typeof(MessageContent))).Serialize(fileStream, config);
Cache.Insert("MessageContent", config);
}
finally
{
if (fileStream != null)
{
((IDisposable)fileStream).Dispose();
}
}
}
public ButtonResult ShowMessage(string message, string title, MessageDialogType messageDialogType)
{
MessageContent messageContent = new MessageContent()
{
Message = message,
Title = title,
MessageDialogValue = messageDialogType
};
IDialogResult dialogResult = null;
_dialogService.ShowDialog(nameof(MessageDialog), new DialogParameters {
{ "MessageContent", messageContent }
}, result => dialogResult = result);
return(dialogResult.Result);
}
private int SendAnEmail(MessageContent emailMessage)
{
int result;
try
{
VfsCustomerService.Business.SendTemplateEmailWithParam sendTemplateEmailWithParam = new SendTemplateEmailWithParam();
sendTemplateEmailWithParam.Send(emailMessage);
result = (int)EmailCommandStatus.SuccessAndFinish;
}
catch (Exception ex)
{
SendEmailException sendEmailException = new SendEmailException(emailMessage, ex);
listError.Add(sendEmailException);
result = (int)EmailCommandStatus.FailAndFinish;
}
return result;
}
public async Task WriteResponseToOutput(string id, MessageContent content)
{
using (await outputWriteSem.UseAsync())
{
await outputWriter.WriteLineAsync("======= Response =======");
await outputWriter.WriteLineAsync(id);
await outputWriter.WriteLineAsync(content.Body.Count(c => c == '\n').ToString());
await outputWriter.WriteLineAsync(content.Body);
await outputWriter.WriteLineAsync("========================");
await outputWriter.FlushAsync();
}
}
protected override void OnRun(MessageContent content, ServerCommandArgs args)
{
if (string.IsNullOrEmpty(content.RoomName))
{
throw new ArgumentException("RoomName");
}
if (string.Equals(content.RoomName, ServerModel.MainRoomName))
{
ServerModel.Api.SendSystemMessage(args.ConnectionId, SystemMessageId.RoomCantLeaveMainRoom);
return;
}
using (var server = ServerModel.Get())
{
Room room;
if (!TryGetRoom(server, content.RoomName, args.ConnectionId, out room))
{
return;
}
if (!room.Users.Contains(args.ConnectionId))
{
ServerModel.Api.SendSystemMessage(args.ConnectionId, SystemMessageId.RoomAccessDenied);
return;
}
room.RemoveUser(args.ConnectionId);
var closeRoomContent = new ClientRoomClosedCommand.MessageContent {
Room = room
};
ServerModel.Server.SendMessage(args.ConnectionId, ClientRoomClosedCommand.CommandId, closeRoomContent);
if (room.Admin == args.ConnectionId)
{
room.Admin = room.Users.FirstOrDefault();
if (room.Admin != null)
{
ServerModel.Api.SendSystemMessage(room.Admin, SystemMessageId.RoomAdminChanged, room.Name);
}
}
RefreshRoom(server, room);
}
}
protected override void OnRun(MessageContent content, CommandArgs args)
{
if (content.Room == null)
{
throw new ArgumentNullException("content.Room");
}
using (var client = ClientModel.Get())
{
Room room = null;
if (content.Room.Type == RoomType.Chat)
{
var textRoom = new ClientRoom(content.Room);
client.Chat.AddRoom(textRoom);
room = textRoom;
}
if (content.Room.Type == RoomType.Voice)
{
var voiceRoom = new ClientVoiceRoom(content.Room);
client.Chat.AddVoiceRoom(voiceRoom);
room = voiceRoom;
}
if (room == null)
{
throw new ModelException(ErrorCode.UnknownRoomType);
}
AddUsers(client.Chat, content.Users);
// Create P2P connections to users if need
if (content.Room.ConnectTo != null)
{
foreach (var nick in content.Room.ConnectTo)
{
ClientModel.Api.Perform(new ClientConnectToPeerAction(nick));
}
}
room.Enable();
}
ClientModel.Notifier.RoomOpened(new RoomOpenedEventArgs(content.Room.Name));
}
public string DelContentType(string id)
{
if (string.IsNullOrWhiteSpace(id))
{
return(MessageContent.Submit_InvalidRow);
}
Guid gId = Guid.Empty;
Guid.TryParse(id, out gId);
if (gId.Equals(Guid.Empty))
{
return(MessageContent.GetString(MessageContent.Submit_Params_GetInvalidRegex, "对应标识值"));
}
ContentType bll = new ContentType();
bll.Delete(gId);
return("1");
}
protected override void OnRun(MessageContent content, CommandArgs args)
{
if (!string.Equals(content.Password, _password, StringComparison.Ordinal))
{
ServerModel.Api.Perform(new ServerSendSystemMessageAction(args.ConnectionId, SystemMessageId.InvalidPassword));
return;
}
AdminCommand command;
if (!TextCommands.TryGetValue(content.TextCommand, out command))
{
ServerModel.Api.Perform(new ServerSendSystemMessageAction(args.ConnectionId, SystemMessageId.TextCommandNotFound));
return;
}
command(content, args);
}
/// <summary>
/// Получить контент сообщения.
/// </summary>
/// <param name="contentLink"></param>
/// <returns></returns>
public async IAsyncEnumerable <char[]> ReadMessageContent(int contentLink, [EnumeratorCancellation] CancellationToken cancellationToken = default)
{
using (MessageContent content = _dataAdapter.GetMessageContent(contentLink))
{
int bufferSize = _appConfig.XSettings().BufferSize;
var buffer = new char[bufferSize];
int charsReaded;
do
{
charsReaded = await content.Value.ReadAsync(buffer, 0, buffer.Length);
if (charsReaded > 0 && !cancellationToken.IsCancellationRequested)
{
yield return(buffer.Take(charsReaded).ToArray());
}
} while (charsReaded > 0 && !cancellationToken.IsCancellationRequested);
}
}
protected static bool IsFullMedia(MessageContent content, bool width = false)
{
switch (content)
{
case MessageLocation location:
case MessageVenue venue:
case MessagePhoto photo:
case MessageVideo video:
case MessageAnimation animation:
return(true);
case MessageInvoice invoice:
return(width && invoice.Photo != null);
default:
return(false);
}
}
/// <summary>
/// receive images from the server
/// </summary>
public async void receive()
{
MessageApi msgApi = MessageApi.getInstance();
UserApi userApi = UserApi.getInstance();
IEnumerable <Message> messages = await msgApi.getGroupMessageData(group.group.id);
StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
LoadingIndicator = true;
if (messages != null && messages.Any())
{
foreach (var msg in messages)
{
if (msg.id != null && !historyContainsMessage(msg.id))
{
var fstream = await msgApi.getMessageFile(group.group.id, msg.id);
if (fstream != null && fstream.Length > 0)
{
StorageFile targetFile = await storageFolder.CreateFileAsync(msg.id + ".png", CreationCollisionOption.ReplaceExisting);
using (Stream targetStream = await targetFile.OpenStreamForWriteAsync())
{
await fstream.CopyToAsync(targetStream);
}
Uri imageUri = new Uri(targetFile.Path, UriKind.Absolute);
User sender = await userApi.getUser(msg.SenderId);
MessageContent mc = new MessageContent(msg, sender, imageUri);
History.Insert(0, mc);
}
else
{
Debug.WriteLine("File with id " + msg.id + " not found");
}
}
}
}
LoadingIndicator = false;
}
public static void onGroupMsg(object sender, XQAppGroupMsgEventArgs e)
{
// XQ.Net.SDK.XQAPI.OutPutLog(e.FromGroup.GetGroupMemberList_B(e.RobotQQ));
//GroupClient client = new GroupClient()
//{
// EventArgs = e,
// Group = e.FromGroup,
// QQ = e.FromQQ,
// RobotQQ = e.RobotQQ
//};
//string r=CommandSystem.Execute(e.Message.Text, client);
//if (!string.IsNullOrEmpty(r))
//{
// e.FromGroup.SendMessage(e.RobotQQ, r);
//}
//if (e.Message.Text == "hello")
//{
// e.FromGroup.SendMessage(e.RobotQQ, "Hi nice to meet you!");
//}
try
{
GroupClient client = DataCenter.GetClient(e.FromGroup, e.RobotQQ);
client.Update(e.FromGroup);
MessageContent content = new MessageContent()
{
FromQQ = e.FromQQ,
FromGroup = client,
Message = e.Message.Text
};
CommandSystem.Execute(content, (msg, target) =>
{
if (!string.IsNullOrEmpty(msg))
{
target.Group.SendMessage(target.RobotQQ, msg);
}
});
}
catch (Exception ex)
{
XQ.Net.SDK.XQAPI.OutPutLog(ex.ToString());
}
}
protected override void OnRun(MessageContent content, ServerCommandArgs args)
{
if (content.File == null)
{
throw new ArgumentNullException("File");
}
if (string.IsNullOrEmpty(content.RoomName))
{
throw new ArgumentException("RoomName");
}
if (!RoomExists(content.RoomName, args.ConnectionId))
{
return;
}
using (var context = ServerModel.Get())
{
var room = context.Rooms[content.RoomName];
if (!room.Users.Contains(args.ConnectionId))
{
ServerModel.Api.SendSystemMessage(args.ConnectionId, MessageId.RoomAccessDenied);
return;
}
if (room.Files.FirstOrDefault(file => file.Equals(content.File)) == null)
{
room.Files.Add(content.File);
}
var sendingContent = new ClientFilePostedCommand.MessageContent
{
File = content.File,
RoomName = content.RoomName
};
foreach (string user in room.Users)
{
ServerModel.Server.SendMessage(user, ClientFilePostedCommand.CommandId, sendingContent);
}
}
}
protected override void OnRun(MessageContent content, CommandArgs args)
{
if (string.IsNullOrEmpty(content.RoomName))
{
throw new ArgumentNullException("content.RoomName");
}
using (var server = ServerModel.Get())
{
if (server.Chat.IsRoomExist(content.RoomName))
{
ServerModel.Api.Perform(new ServerSendSystemMessageAction(args.ConnectionId, SystemMessageId.RoomAlreadyExist));
return;
}
Room room = null;
if (content.Type == RoomType.Chat)
{
var textRoom = new ServerRoom(args.ConnectionId, content.RoomName);
server.Chat.AddRoom(textRoom);
room = textRoom;
}
if (content.Type == RoomType.Voice)
{
var voiceRoom = new ServerVoiceRoom(args.ConnectionId, content.RoomName);
server.Chat.AddVoiceRoom(voiceRoom);
room = voiceRoom;
}
if (room == null)
{
throw new ArgumentException("content.RoomType");
}
var sendingContent = new ClientRoomOpenedCommand.MessageContent
{
Room = room.ToDto(args.ConnectionId),
Users = server.Chat.GetRoomUserDtos(room.Name)
};
ServerModel.Server.SendMessage(args.ConnectionId, ClientRoomOpenedCommand.CommandId, sendingContent);
}
}
public bool IsValid(MessageContent content, bool primary)
{
// We can't recycle it as we must destroy CanvasAnimatedControl on Unload.
if (Player.IsUnloaded)
{
return(false);
}
if (content is MessageSticker sticker)
{
return(sticker.Sticker.IsAnimated);
}
else if (content is MessageText text && text.WebPage != null && !primary)
{
return(text.WebPage.Sticker != null && text.WebPage.Sticker.IsAnimated);
}
return(false);
}
public static void UpdateMessageContent(MessageContent messageContent)
{
try
{
MessageContentDAO messageContentDAO = new MessageContentDAO();
messageContentDAO.UpdateMessageContent(messageContent);
}
catch (ApplicationException)
{
throw;
}
catch (Exception ex)
{
// log this exception
log4net.Util.LogLog.Error(ex.Message, ex);
// wrap it and rethrow
throw new ApplicationException(SR.BusinessUpdateMessageContentException, ex);
}
}
protected override void OnRun(MessageContent content, CommandArgs args)
{
if (string.IsNullOrEmpty(content.RoomName))
{
throw new ArgumentException("content.RoomName");
}
if (content.File == null)
{
throw new ArgumentNullException("content.File");
}
using (var server = ServerModel.Get())
{
Room room;
if (!TryGetRoom(server.Chat, content.RoomName, args.ConnectionId, out room))
{
return;
}
if (!room.IsUserExist(args.ConnectionId))
{
ServerModel.Api.Perform(new ServerSendSystemMessageAction(args.ConnectionId, SystemMessageId.RoomAccessDenied));
return;
}
if (!room.IsFileExist(content.File.Id))
{
room.AddFile(new FileDescription(content.File));
}
var sendingContent = new ClientFilePostedCommand.MessageContent
{
File = content.File,
RoomName = content.RoomName
};
foreach (var user in room.Users)
{
ServerModel.Server.SendMessage(user, ClientFilePostedCommand.CommandId, sendingContent);
}
}
}
private BattleUser GetUser(MessageContent client)
{
string id = client.FromGroup.Group.Id + "_" + client.FromQQ.Id;
if (Users.ContainsKey(id))
{
return(Users[id]);
}
Users[id] = new BattleUser()
{
QQId = client.FromQQ.Id,
QQName = client.FromQQ.GetNick(client.FromGroup.RobotQQ),
EcUser = CommandSystem.GetModule(typeof(EcommerceCommand)).GetPlugInter("get").Invoke(client),
Group = client.FromGroup
};
return(Users[id]);
}
public string SaveUserInRole(string userName, string roleName, bool isInRole)
{
if (!HttpContext.Current.User.IsInRole("Administrators"))
{
return(MessageContent.Role_InvalidError);
}
if (string.IsNullOrWhiteSpace(userName))
{
return(MessageContent.GetString(MessageContent.Request_InvalidArgument, "用户名"));
}
if (string.IsNullOrWhiteSpace(roleName))
{
return(MessageContent.GetString(MessageContent.Request_InvalidArgument, "角色"));
}
try
{
if (isInRole)
{
if (!Roles.IsUserInRole(userName, roleName))
{
Roles.AddUserToRole(userName, roleName);
}
}
else
{
if (Roles.IsUserInRole(userName, roleName))
{
Roles.RemoveUserFromRole(userName, roleName);
}
}
return("1");
}
catch (System.Configuration.Provider.ProviderException pex)
{
return(pex.Message);
}
catch (Exception ex)
{
return(ex.Message);
}
}
public object BasicQueue(
[FromServices] RabbitMQConfigurations configurations,
[FromBody] MessageContent conteudo)
{
lock (_CONTADOR)
{
_CONTADOR.Incrementar();
var factory = new ConnectionFactory()
{
HostName = configurations.HostName,
Port = configurations.Port,
UserName = configurations.UserName,
Password = configurations.Password
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "TestesASPNETCore",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
string message =
$"{DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss")} - " +
$"Conteúdo da Mensagem: {conteudo.Message}";
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "",
routingKey: "TestesASPNETCore",
basicProperties: null,
body: body);
}
return(new
{
Resultado = "Mensagem encaminhada com sucesso"
});
}
}
protected override void OnRun(MessageContent content, CommandArgs args)
{
if (string.IsNullOrEmpty(content.RoomName))
{
throw new ArgumentException("content.RoomName");
}
if (string.IsNullOrEmpty(content.NewAdmin))
{
throw new ArgumentNullException("content.NewAdmin");
}
if (content.RoomName == ServerChat.MainRoomName)
{
ServerModel.Api.Perform(new ServerSendSystemMessageAction(args.ConnectionId, SystemMessageId.RoomAccessDenied));
return;
}
using (var server = ServerModel.Get())
{
Room room;
if (!TryGetRoom(server.Chat, content.RoomName, args.ConnectionId, out room))
{
return;
}
if (room.Admin != args.ConnectionId)
{
ServerModel.Api.Perform(new ServerSendSystemMessageAction(args.ConnectionId, SystemMessageId.RoomAccessDenied));
return;
}
if (!room.IsUserExist(content.NewAdmin))
{
ServerModel.Api.Perform(new ServerSendSystemMessageAction(args.ConnectionId, SystemMessageId.RoomUserNotExist));
return;
}
room.Admin = content.NewAdmin;
ServerModel.Api.Perform(new ServerSendSystemMessageAction(content.NewAdmin, SystemMessageId.RoomAdminChanged, room.Name));
}
}
protected override void OnRun(MessageContent content, ServerCommandArgs args)
{
if (string.IsNullOrEmpty(content.RoomName))
{
throw new ArgumentException("RoomName");
}
if (string.IsNullOrEmpty(content.NewAdmin))
{
throw new ArgumentNullException("NewAdmin");
}
if (string.Equals(content.RoomName, ServerModel.MainRoomName))
{
ServerModel.Api.SendSystemMessage(args.ConnectionId, SystemMessageId.RoomAccessDenied);
return;
}
using (var server = ServerModel.Get())
{
Room room;
if (!TryGetRoom(server, content.RoomName, args.ConnectionId, out room))
{
return;
}
if (!room.Admin.Equals(args.ConnectionId))
{
ServerModel.Api.SendSystemMessage(args.ConnectionId, SystemMessageId.RoomAccessDenied);
return;
}
if (!room.Users.Contains(content.NewAdmin))
{
ServerModel.Api.SendSystemMessage(args.ConnectionId, SystemMessageId.RoomUserNotExist);
return;
}
room.Admin = content.NewAdmin;
ServerModel.Api.SendSystemMessage(content.NewAdmin, SystemMessageId.RoomAdminChanged, room.Name);
}
}
public GeneratedMessage GenerateMessage([FromBody] MessageContent messageContent)
{
XDocument doc = new XDocument();
doc.Add(new XElement("Response"));
XElement message = new XElement("Message");
message.Add(messageContent.Text);
if (!string.IsNullOrWhiteSpace(messageContent.To))
{
message.Add(new XAttribute("to", messageContent.To));
}
if (!string.IsNullOrWhiteSpace(messageContent.From))
{
message.Add(new XAttribute("from", messageContent.From));
}
if (!string.IsNullOrWhiteSpace(messageContent.Action))
{
message.Add(new XAttribute("action", messageContent.Action));
message.Add(new XAttribute("method", messageContent.Method));
}
if (!string.IsNullOrWhiteSpace(messageContent.StatusCallbackUrl))
{
message.Add(new XAttribute("statusCallback", messageContent.StatusCallbackUrl));
}
doc.Root.Add(message);
using (MemoryStream outputStream = new MemoryStream())
{
doc.Save(outputStream);
return(new GeneratedMessage()
{
TwiMLMessage = Encoding.UTF8.GetString(outputStream.ToArray())
});
}
}
private void OsposobiAdapter()
{
bool send = false;
for (int i = 0; i < 20; i++)
{
MessageContent message = new MessageContent();
int broj = i + 1;
message.Message = "Probna poruka " + broj;
message.Name = "Ime " + broj;
message.Time = DateTime.Now.ToShortTimeString();
message.IsSend = send;
send = !send;
_listMessage.Add(message);
}
ListViewAdapter adapter = new ListViewAdapter(this, _listMessage);
_listChat.Adapter = adapter;
}
private BattleUser GetUserByGroupMember(GroupMember member, MessageContent client)
{
string id = client.FromGroup.Group.Id + "_" + member.QQ;
if (Users.ContainsKey(id))
{
Users[id].QQName = !string.IsNullOrEmpty(member.GroupNickName) ? member.GroupNickName : member.NickName;
return(Users[id]);
}
Users[id] = new BattleUser()
{
QQId = member.QQ,
QQName = string.IsNullOrEmpty(member.GroupNickName)? member.GroupNickName:member.NickName,
EcUser = CommandSystem.GetModule(typeof(EcommerceCommand)).GetPlugInter("get").Invoke(client),
Group = client.FromGroup
};
return(Users[id]);
}
private void AddMessagesToJsonContainer(IJsonContainer jsonContainer)
{
foreach (var item in AllMessages.Messages)
{
MessageContent messageContent = new MessageContent();
messageContent.Id = item.Id;
messageContent.MessageAlignment = "left";
messageContent.MessageColour = SenderReceiwer.ReceiveBubleColor;
messageContent.MessagePicture = item.MessagePicture;
messageContent.MessagePictureVisibility = "visible";
messageContent.MessageText = item.MessageText;
messageContent.MessageTime = item.MessageTime;
messageContent.Name = item.Name;
messageContent.Pic = item.Pic;
messageContent.PictureChanged = item.PictureChanged;
jsonContainer.Messages.Add(messageContent);
}
}
public async Task <MessageContent> HandleRequest(Peer peer, string id, MessageContent content, ILogger logger)
{
if (!requestHandlers.TryGetValue(id, out var handler))
{
logger.LogError($"Received unknown request: {id}");
return(new MessageContent(MessageStatus.RequestNotSupported, "null"));
}
try
{
var response = await handler(peer, content);
return(new MessageContent(response.Status, JsonConvert.SerializeObject(response)));
}
catch (JsonException)
{
logger.LogError($"Received request with invalid body: {id}");
return(new MessageContent(MessageStatus.InvalidRequestBody, "null"));
}
}
public static void Execute(MessageContent content, Action <string, GroupClient> callback)
{
Func <string, MessageContent, string> cmd = null;
string message = content.Message;
if (!message.StartsWith("#"))
{
return;
}
string _cmd = message.IndexOf(" ") > 0 ? message.Substring(1, message.IndexOf(" ") - 1).Trim() : message.Substring(1).Trim();
if (Actions.TryGetValue(_cmd, out cmd))
{
string v = message.Substring(message.IndexOf(" ") + 1).Trim();
string r = cmd.Invoke(v, content);
callback.Invoke(r, content.FromGroup);
}
//return message;
}
/// <summary>
/// 保存短信内容配置
/// </summary>
/// <param name="config"></param>
public static void SaveMessageContentConfig(MessageContent config)
{
//using (FileStream fs = new FileStream(WorkDirectory + "\\Data\\MessageContent.xml", FileMode.Create))
//{
// XmlSerializer xs = new XmlSerializer(typeof(MessageContent));
// xs.Serialize(fs, config);
// Core.Cache.Insert("MessageContent", config);
//}
string sDirectory = Himall.Core.Helper.IOHelper.urlToVirtual(WorkDirectory) + "/Data/MessageContent.xml";
XmlSerializer xml = new XmlSerializer(typeof(MessageContent));
MemoryStream Stream = new MemoryStream();
xml.Serialize(Stream, config);
byte[] b = Stream.ToArray();
MemoryStream stream2 = new MemoryStream(b);
Himall.Core.HimallIO.CreateFile(sDirectory, stream2, Core.FileCreateType.Create);
}
/// <summary>
/// 发送多条消息</summary>
/// <param name="messageContent">消息封包</param>
/// <param name="messageReceivers">消息接收者</param>
public virtual SendMessageResult SendMultiMessage(MessageContent messageContent, MultiMessageReceiver messageReceivers)
{
Message message = new Message {
Type = messageContent.Type, Content = messageContent
};
// 获取token，检查token的有效性
AccessToken token = GetAccessToken();
if (!token.Success)
{
return(new SendMessageResult(false, token.Error));
}
NameValueCollection parameters = new NameValueCollection();
parameters.Add("access_token", token.Token);
parameters.Add("message", SerializeMessage(message));
if (messageReceivers.IdType == PersonMessageReceiverIdType.LoginId)
{
parameters.Add("loginIds", messageReceivers.ToId);
}
else if (messageReceivers.IdType == PersonMessageReceiverIdType.UserId)
{
parameters.Add("userIds", messageReceivers.ToId);
}
parameters.Add("userNames", messageReceivers.ToName);
parameters.Add("id_type", ((int)messageReceivers.IdType).ToString());
parameters.Add("msgIds", MakeMessageIds(messageReceivers.Length));
HttpRequestResult requestResult = DoPost(_messageSendServiceUrl, parameters);
if (!requestResult.Success)
{
return(new SendMessageResult(false, requestResult.Result));
}
return(JsonConvert.DeserializeObject <SendMessageResult>(requestResult.Result));
}
public IActionResult SentMessage([FromBody] MessageContent Message)
{
try
{
if (Message == null)
{
return(BadRequest("حذث خطأ في ارسال البيانات الرجاء إعادة الادخال"));
}
var userId = this.help.GetCurrentUser(HttpContext);
if (userId <= 0)
{
return(BadRequest("لا يمكنك الوصول لهذه الصفحة , الرجاء تسجيل الدخول"));
}
Messages MS = new Messages();
MS.CreatedBy = userId;
MS.CreatedOn = DateTime.Now;
MS.Payload = Message.Payload;
MS.Subject = Message.Subject;
db.Messages.Add(MS);
MessageTransaction MT = new MessageTransaction();
MT.SentByStudent = userId;
MT.RecivedByStudent = Message.RecivedByStudent;
MT.MessageId = MS.MesssageId;
MT.CreatedBy = userId;
MT.CreatedOn = DateTime.Now;
MT.IsRead = 1;
db.MessageTransaction.Add(MT);
db.SaveChanges();
return(Ok("لقد قمت بإرسال الرسالة بنـجاح"));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
private int SendAnEmail(MessageContent emailMessage)
{
int result;
try
{
// EmailMessageService.EmailMessageWS emailMessageService = new EmailMessageService.EmailMessageWS();
//emailMessageService.SendAnEmail(emailMessage);
VfsCustomerService.Business.SendTemplateEmailWithParam sendTemplateEmailWithParam = new SendTemplateEmailWithParam();
sendTemplateEmailWithParam.SmtpServer = "mail.vfs.com.vn";
sendTemplateEmailWithParam.SmtpPort = 25;
sendTemplateEmailWithParam.Send(emailMessage);
result = (int)EmailCommandStatus.SuccessAndFinish;
}
catch (Exception ex)
{
SendEmailException sendEmailException = new SendEmailException(emailMessage, ex);
listError.Add(sendEmailException);
result = (int)EmailCommandStatus.FailAndFinish;
}
return result;
}
public virtual void CreateMessageContent(MessageContent messageContent)
{
try
{
Database database = DatabaseFactory.CreateDatabase("CustommerServiceConnection");
DbCommand dbCommand = database.GetStoredProcCommand("spMessageContentInsert");
database.AddInParameter(dbCommand, "@ContentTemplateID", DbType.Int32, messageContent.ContentTemplateID);
database.AddInParameter(dbCommand, "@ServiceTypeID", DbType.Int32, messageContent.ServiceTypeID);
database.AddInParameter(dbCommand, "@Sender", DbType.String, messageContent.Sender);
database.AddInParameter(dbCommand, "@Receiver", DbType.String, messageContent.Receiver);
database.AddInParameter(dbCommand, "@Subject", DbType.String, messageContent.Subject);
database.AddInParameter(dbCommand, "@BodyContentType", DbType.String, messageContent.BodyContentType);
database.AddInParameter(dbCommand, "@BodyEncoding", DbType.String, messageContent.BodyEncoding);
database.AddInParameter(dbCommand, "@BodyMessage", DbType.String, messageContent.BodyMessage);
database.AddInParameter(dbCommand, "@CreatedDate", DbType.DateTime, messageContent.CreatedDate);
database.AddInParameter(dbCommand, "@ModifiedDate", DbType.DateTime, messageContent.ModifiedDate);
database.AddInParameter(dbCommand, "@Status", DbType.Int32, messageContent.Status);
database.AddOutParameter(dbCommand, "@MessageContentID", DbType.Int32, 0);
database.AddInParameter(dbCommand, "@ServiceID", DbType.String, messageContent.ServiceID);
database.AddInParameter(dbCommand, "@CommandCode", DbType.String, messageContent.CommandCode);
database.AddInParameter(dbCommand, "@Request", DbType.String, messageContent.Request);
database.AddInParameter(dbCommand, "@MoID", DbType.String, messageContent.MoID);
database.AddInParameter(dbCommand, "@ChargeYN", DbType.String, messageContent.ChargeYN);
database.AddInParameter(dbCommand, "@TotalMessages", DbType.Int16, messageContent.TotalMessages);
database.ExecuteNonQuery(dbCommand);
messageContent.MessageContentID = (int)database.GetParameterValue(dbCommand, "@MessageContentID");
}
catch (Exception ex)
{
// log this exception
log4net.Util.LogLog.Error(ex.Message, ex);
// wrap it and rethrow
throw new ApplicationException(SR.DataAccessCreateMessageContentException, ex);
}
}
public static void CreateMessage(Customer cust, string contentToBeSent, string contentToBeSentSms, ContentTemplate contentTemplate, ContentTemplate contentTemplateSms)
{
if (cust != null)
{
SimpleAES encryptEmail = new SimpleAES();
MessageContent messageContent = null;
messageContent = new MessageContent();
messageContent.Sender = contentTemplate.Sender;
messageContent.Subject = contentTemplate.Subject;
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
messageContent.BodyMessage = ReplaceBodyMessage(contentTemplate.BodyMessage, contentToBeSent);
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
//in case the message is type of email check if the email address is valid
if (cust.ReceiveRelatedStockEmail.Trim() == "Y")
{
messageContent.Receiver = cust.Email;
messageContent.BodyMessage = messageContent.BodyMessage.Replace("$#email#", encryptEmail.EncryptToString(cust.Email));
if (ValidateEmail(messageContent.Receiver) == true)
{
MessageContentService.CreateMessageContent(messageContent);
ContentTemplateAttachementCollection contentTemplateAttachementColl = ContentTemplateAttachementService.GetContentTemplateAttachementList(contentTemplate.ContentTemplateID, ContentTemplateAttachementColumns.ModifiedDate, "DESC");
foreach (ContentTemplateAttachement attachement in contentTemplateAttachementColl)
{
MessageContentAttachement messageContentAttachement = new MessageContentAttachement();
messageContentAttachement.AttachementDescription = attachement.AttachementDescription;
messageContentAttachement.AttachementDocument = attachement.AttachementDocument;
messageContentAttachement.MessageContentID = messageContent.MessageContentID;
messageContentAttachement.ModifiedDate = DateTime.Now;
messageContentAttachement.CreatedDate = DateTime.Now;
MessageContentAttachementService.CreateMessageContentAttachement(messageContentAttachement);
}
}
}
if (cust.ReceiveRelatedStockSms.Trim() == "Y")
{
messageContent = null;
messageContent = new MessageContent();
messageContent.Sender = contentTemplateSms.Sender;
messageContent.Subject = contentTemplateSms.Subject;
messageContent.BodyContentType = contentTemplateSms.BodyContentType;
messageContent.BodyEncoding = contentTemplateSms.BodyEncoding;
messageContent.BodyMessage = ReplaceBodyMessage(contentTemplateSms.BodyMessage, contentToBeSentSms);
messageContent.ContentTemplateID = contentTemplateSms.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplateSms.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
messageContent.Receiver = cust.Mobile;
MessageContentService.CreateMessageContent(messageContent);
ContentTemplateAttachementCollection contentTemplateAttachementColl = ContentTemplateAttachementService.GetContentTemplateAttachementList(contentTemplateSms.ContentTemplateID, ContentTemplateAttachementColumns.ModifiedDate, "DESC");
foreach (ContentTemplateAttachement attachement in contentTemplateAttachementColl)
{
MessageContentAttachement messageContentAttachement = new MessageContentAttachement();
messageContentAttachement.AttachementDescription = attachement.AttachementDescription;
messageContentAttachement.AttachementDocument = attachement.AttachementDocument;
messageContentAttachement.MessageContentID = messageContent.MessageContentID;
messageContentAttachement.ModifiedDate = DateTime.Now;
messageContentAttachement.CreatedDate = DateTime.Now;
MessageContentAttachementService.CreateMessageContentAttachement(messageContentAttachement);
}
}
}
}
public static void CreateMessage(Customer cust, string contentToBeSentSms, ContentTemplate contentTemplateSms)
{
MessageContent messageContent = new MessageContent();
if (cust.ReceiveRelatedStockSms.Trim() == "Y")
{
messageContent = null;
messageContent = new MessageContent();
messageContent.Sender = contentTemplateSms.Sender;
messageContent.Subject = contentTemplateSms.Subject;
messageContent.BodyContentType = contentTemplateSms.BodyContentType;
messageContent.BodyEncoding = contentTemplateSms.BodyEncoding;
messageContent.BodyMessage = ReplaceBodyMessage(contentTemplateSms.BodyMessage, contentToBeSentSms);
messageContent.ContentTemplateID = contentTemplateSms.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplateSms.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
messageContent.Receiver = cust.Mobile;
MessageContentService.CreateMessageContent(messageContent);
}
}
private void SaveDetail()
{
this.paramater();
if (this.action == "modify")
{
this.messageContent = MessageContentService.GetMessageContent(this.messageContentID);
}
else
{
this.messageContent = new MessageContent();
}
if (this.messageContent != null)
{
messageContent.ContentTemplateID = Convert.ToInt32(this.LoadTemplateType.SelectedValue);
messageContent.ServiceTypeID = Convert.ToInt32(this.LoadServiceType.SelectedValue);
messageContent.Sender = this.InputSender.Value;
messageContent.Receiver = this.InputReceiver.Value;
messageContent.Subject = this.inputSuject.Value;
messageContent.BodyContentType = this.InputBodyContentType.Value;
messageContent.BodyEncoding = this.InputBodyEncoding.Value;
messageContent.BodyMessage = this.InputBodyMessager.Value;
}
if (this.action == "modify")
{
messageContent.Status = 0;
messageContent.ModifiedDate = DateTime.Now;
MessageContentService.UpdateMessageContent(this.messageContent);
}
else
{
messageContent.ModifiedDate = messageContent.CreatedDate = DateTime.Now;
MessageContentService.CreateMessageContent(this.messageContent);
}
Response.Redirect("MessengerSending.aspx");
}
public bool ReceivedHandshakeExistingSessionValidations(TcpSession existingSession , MessageContent.HandshakeMessageContent remoteServerData)
{
//check if hostname changed
if (existingSession.RemoteHostname != remoteServerData.Hostname)
{
logger.Warn("[" + _description + "-T] Hostname changed for session [" + remoteServerData.IpAddress + "] from [" + existingSession.RemoteHostname + "] to [" + remoteServerData.Hostname + "]; invalidating existing session");
_evtRaiser.RaiseEvent("SessionError", "UdpReceiverListener: Hostname changed for session [" + remoteServerData.IpAddress + "] from [" + existingSession.RemoteHostname + "] to [" + remoteServerData.Hostname + "]; invalidating existing session", null, _threadStatus.NodeID, _threadStatus.ParentNodeID);
return true;
}
//check if handshake port changed
if (existingSession.RemoteHandshakePort != remoteServerData.HandshakePort)
{
logger.Warn("[" + _description + "-T] Handshake port changed for session [" + remoteServerData.IpAddress + "] from [" + existingSession.RemoteHandshakePort + "] to [" + remoteServerData.HandshakePort + "]; invalidating existing session");
_evtRaiser.RaiseEvent("SessionError", "UdpReceiverListener: Handshake port changed for session [" + remoteServerData.IpAddress + "] from [" + existingSession.RemoteHandshakePort + "] to [" + remoteServerData.HandshakePort + "]; invalidating existing session", null, _threadStatus.NodeID, _threadStatus.ParentNodeID);
return true;
}
//check if session initialization is complete
if (!existingSession.IsSessionInitReceived || !existingSession.IsSessionInitSent)
{
logger.Warn("[" + _description + "-T] Handshake message received for session [" + remoteServerData.IpAddress + "] where initialization never completed; invalidating existing session");
_evtRaiser.RaiseEvent("SessionError", "UdpReceiverListener: Handshake message received for session [" + remoteServerData.IpAddress + "] where initialization never completed; invalidating existing session", null, _threadStatus.NodeID, _threadStatus.ParentNodeID);
return true;
}
//check if session contains message transmitter errors
if (existingSession.Transmitter != null && existingSession.Transmitter.ThreadStatus.MessageErrorCount > 0)
{
logger.Warn("[" + _description + "-T] Handshake message received for session [" + remoteServerData.IpAddress + "] where there are message transmitter errors; invalidating existing session");
_evtRaiser.RaiseEvent("SessionError", "UdpReceiverListener: Handshake message received for session [" + remoteServerData.IpAddress + "] where there are message transmitter errors; invalidating existing session", null, _threadStatus.NodeID, _threadStatus.ParentNodeID);
return true;
}
//check if session contains message receiver errors
if (existingSession.Receiver != null && existingSession.Receiver.ThreadStatus.MessageErrorCount > 0)
{
logger.Warn("[" + _description + "-T] Handshake message received for session [" + remoteServerData.IpAddress + "] where there are message receiver errors; invalidating existing session");
_evtRaiser.RaiseEvent("SessionError", "UdpReceiverListener: Handshake message received for session [" + remoteServerData.IpAddress + "] where there are message receiver errors; invalidating existing session", null, _threadStatus.NodeID, _threadStatus.ParentNodeID);
return true;
}
//check if session validations valid
if (existingSession.SessionValidationFailedDate > DateTime.MinValue)
{
logger.Warn("[" + _description + "-T] Handshake message received for session [" + remoteServerData.IpAddress + "] where session integrity validations failed; invalidating existing session");
_evtRaiser.RaiseEvent("SessionError", "UdpReceiverListener: Handshake message received for session [" + remoteServerData.IpAddress + "] where session integrity validations failed; invalidating existing session", null, _threadStatus.NodeID, _threadStatus.ParentNodeID);
return true;
}
//check if session transmitter thread health failed
if (existingSession.Transmitter != null && existingSession.Transmitter.ThreadStatus.CalculateThreadHealthFailed())
{
logger.Warn("[" + _description + "-T] Handshake message received for session [" + remoteServerData.IpAddress + "] where session transmitter thread health failed; invalidating existing session");
_evtRaiser.RaiseEvent("SessionError", "UdpReceiverListener: Handshake message received for session [" + remoteServerData.IpAddress + "] where session transmitter thread health failed; invalidating existing session", null, _threadStatus.NodeID, _threadStatus.ParentNodeID);
return true;
}
//check if session receiver thread health failed
if (existingSession.Receiver != null && existingSession.Receiver.ThreadStatus.CalculateThreadHealthFailed())
{
logger.Warn("[" + _description + "-T] Handshake message received for session [" + remoteServerData.IpAddress + "] where session receiver thread health failed; invalidating existing session");
_evtRaiser.RaiseEvent("SessionError", "UdpReceiverListener: Handshake message received for session [" + remoteServerData.IpAddress + "] where session receiver thread health failed; invalidating existing session", null, _threadStatus.NodeID, _threadStatus.ParentNodeID);
return true;
}
//check if session transmitter status is non-active
if (existingSession.Transmitter != null && (existingSession.Transmitter.ThreadStatus.Status == Niawa.Threading.ThreadStatus.STATUS_STOPPED ||
existingSession.Transmitter.ThreadStatus.Status == Niawa.Threading.ThreadStatus.STATUS_SUSPENDED ||
existingSession.Transmitter.ThreadStatus.Status == Niawa.Threading.ThreadStatus.STATUS_UNKNOWN ||
existingSession.Transmitter.ThreadStatus.Status == Niawa.Threading.ThreadStatus.STATUS_FINALIZED))
{
logger.Warn("[" + _description + "-T] Handshake message received for session [" + remoteServerData.IpAddress + "] where session transmitter status is non-active; invalidating existing session");
_evtRaiser.RaiseEvent("SessionError", "UdpReceiverListener: Handshake message received for session [" + remoteServerData.IpAddress + "] where session transmitter status is non-active; invalidating existing session", null, _threadStatus.NodeID, _threadStatus.ParentNodeID);
return true;
}
//check if session receiver status is non-active
if (existingSession.Receiver != null && (existingSession.Receiver .ThreadStatus.Status == Niawa.Threading.ThreadStatus.STATUS_STOPPED ||
existingSession.Receiver.ThreadStatus.Status == Niawa.Threading.ThreadStatus.STATUS_SUSPENDED ||
existingSession.Receiver.ThreadStatus.Status == Niawa.Threading.ThreadStatus.STATUS_UNKNOWN ||
existingSession.Receiver.ThreadStatus.Status == Niawa.Threading.ThreadStatus.STATUS_FINALIZED))
{
logger.Warn("[" + _description + "-T] Handshake message received for session [" + remoteServerData.IpAddress + "] where session receiver status is non-active; invalidating existing session");
_evtRaiser.RaiseEvent("SessionError", "UdpReceiverListener: Handshake message received for session [" + remoteServerData.IpAddress + "] where session receiver status is non-active; invalidating existing session", null, _threadStatus.NodeID, _threadStatus.ParentNodeID);
return true;
}
return false;
}
public static string RejectRelatedSmsMessage(string UserID, string ServiceID, string CommandCode, string Message, string RequestID, string MoID, string Username, string Password, Int32 invalidSMSContentTemplateId, Int32 replyRejectRelatedMessageContentTemplateId, Int32 invalidAccountSMSContentTemplateId)
{
string returnValue = "1";
int result;
string[] messagePrased;
ContentTemplate contentTemplate = null;
try
{
messagePrased = Message.Normalize().Split(' ');
if (messagePrased.Length == 4)
{
Customer customer = null;
customer = CustomerService.GetCustomer(messagePrased[3]);
if (customer != null)
{
customer.Mobile = "84" + customer.Mobile.Substring(1);
if (customer.Mobile.ToString().Trim().Equals(UserID.ToString().Trim()))
{
customer.ReceiveRelatedStockSms = "N";
CustomerService.UpdateCustomer(customer);
contentTemplate = ContentTemplateService.GetContentTemplate(replyRejectRelatedMessageContentTemplateId);
MessageContent messageContent = null;
if (contentTemplate != null)
{
messageContent = new MessageContent();
messageContent.Sender = contentTemplate.Sender;
messageContent.Receiver = UserID;
messageContent.Subject = contentTemplate.Subject;
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
messageContent.BodyMessage = contentTemplate.BodyMessage;
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
messageContent.Request = RequestID;
messageContent.MoID = MoID;
messageContent.ServiceID = ServiceID;
messageContent.CommandCode = CommandCode;
}
MessageContentService.CreateMessageContent(messageContent);
}
else
{
SendInValidResponseMessage(UserID, ServiceID, CommandCode, Message, RequestID, MoID, Username, Password, invalidAccountSMSContentTemplateId);
}
}
else
{
SendInValidResponseMessage(UserID, ServiceID, CommandCode, Message, RequestID, MoID, Username, Password, invalidSMSContentTemplateId);
}
}
}
catch(Exception ex)
{
log4net.Util.LogLog.Error(ex.Message, ex);
// wrap it and rethrow
//throw new ApplicationException(SR.BusinessSendSMSToCoreSecuritiesException, ex);
return "-1";
}
return returnValue;
}
public int SendAnSMS(MessageContent emailMessage)
{
int result = 0;
try
{
if(emailMessage.BodyMessage.Length <= 160)
{
VfsCustomerService.Business.SendSMS sendSMS = new SendSMS(this.userName, this.password);
result = sendSMS.Send(emailMessage);
}
else
{
VfsCustomerService.Business.SendSMS sendSMS;
string FirstMessage = Ultility.CutAddressHead(emailMessage.BodyMessage);
string SecondMessage = Ultility.CutAddressEnd(emailMessage.BodyMessage);
emailMessage.BodyMessage = FirstMessage;
sendSMS = new SendSMS(this.userName, this.password);
result = sendSMS.Send(emailMessage);
emailMessage.BodyMessage = SecondMessage;
sendSMS = new SendSMS(this.userName, this.password);
result = sendSMS.Send(emailMessage);
}
}
catch (Exception ex)
{
SendEmailException sendEmailException = new SendEmailException(emailMessage, ex);
listError.Add(sendEmailException);
}
return result;
}
public static string PreviewMessage(string filePath, string fileName, ContentTemplate contentTemplate, NameValueCollection parameters)
{
string[] typicalHeaders = null;
string[] headers;
List<string[]> data = null;
Hashtable hastableParameters = new Hashtable();
string returnValue = string.Empty;
try
{
ReadCvsHeader(filePath + fileName, out headers);
ReadCvsData(filePath + fileName, out headers, out data);
if (!ValidateHeaders(typicalHeaders, headers))
{
throw new InvalidDataException("CSV file is invalid format!");
}
foreach (string[] items in data)
{
MessageContent messageContent = null;
messageContent = new MessageContent();
messageContent.Sender = contentTemplate.Sender;
Customer customer = null;
string customerId = items[0].Replace("K", "C");
customer = CustomerService.GetCustomer(customerId);
if (customer != null)
{
if (contentTemplate.ServiceTypeID == 1)
messageContent.Receiver = customer.Email;
else
messageContent.Receiver = customer.Mobile;
messageContent.Subject = contentTemplate.Subject;
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
hastableParameters = ConvertParametersToHastable(parameters);
messageContent.BodyMessage = ReplaceBodyMessage(contentTemplate.BodyMessage, hastableParameters, items);
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
returnValue = messageContent.BodyMessage;
break;
}
}
}
catch (Exception ex)
{
// log this exception
log4net.Util.LogLog.Error(ex.Message, ex);
// wrap it and rethrow
throw new ApplicationException(SR.BusinessImport_CreateMessageWithEmailException, ex);
}
finally
{
if (data != null) data = null;
}
return returnValue;
}
public WindowResponse ShowMessage(MessageContent content)
{
return ShowMessage(content, null);
}
public static void CreateMessageWhenNewCustomer(Customer customer, ContentTemplate contentTemplate, string MorE)
{
MessageContent messageContent = null;
messageContent = new MessageContent();
messageContent.Sender = contentTemplate.Sender;
if(MorE == "M")
messageContent.Receiver = customer.Mobile;
else
messageContent.Receiver = customer.Email;
messageContent.Subject = contentTemplate.Subject;
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
messageContent.BodyMessage = contentTemplate.BodyMessage.Replace("#name#", customer.CustomerName).Replace("#customerid#", customer.CustomerId);
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
MessageContentService.CreateMessageContent(messageContent);
ContentTemplateAttachementCollection contentTemplateAttachementColl = ContentTemplateAttachementService.GetContentTemplateAttachementList(contentTemplate.ContentTemplateID, ContentTemplateAttachementColumns.ModifiedDate, "DESC");
foreach (ContentTemplateAttachement attachement in contentTemplateAttachementColl)
{
MessageContentAttachement messageContentAttachement = new MessageContentAttachement();
messageContentAttachement.AttachementDescription = attachement.AttachementDescription;
messageContentAttachement.AttachementDocument = attachement.AttachementDocument;
messageContentAttachement.MessageContentID = messageContent.MessageContentID;
messageContentAttachement.ModifiedDate = DateTime.Now;
messageContentAttachement.CreatedDate = DateTime.Now;
MessageContentAttachementService.CreateMessageContentAttachement(messageContentAttachement);
}
}
public static void SendBirthdaySmsMessage(Int32 birthdaySmsMessageTemplateId)
{
ContentTemplate contentTemplate = null;
if (DateTime.Now.Hour < 8 && DateTime.Now.Hour > 17) return;
if (BirthdayMessageLogService.GetBirthdayMessageLog(DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString().PadLeft(2, '0') + DateTime.Now.Day.ToString().PadLeft(2, '0')) != null) return;
CustomerCollection customerCollection = CustomerService.GetCustomerListByBirthDay();
contentTemplate = ContentTemplateService.GetContentTemplate(birthdaySmsMessageTemplateId);
if (contentTemplate != null)
{
foreach (Customer cust in customerCollection)
{
MessageContent messageContent = null;
messageContent = new MessageContent();
messageContent.Sender = contentTemplate.Sender;
messageContent.Receiver = cust.Mobile;
messageContent.Subject = contentTemplate.Subject;
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
messageContent.BodyMessage = contentTemplate.BodyMessage;
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
MessageContentService.CreateMessageContent(messageContent);
}
BirthdayMessageLog birthdayMessageLog = new BirthdayMessageLog();
birthdayMessageLog.BirthdayMessageDay = DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString().PadLeft(2,'0') + DateTime.Now.Day.ToString().PadLeft(2,'0');;
birthdayMessageLog.ProccessYN = "Y";
BirthdayMessageLogService.CreateBirthdayMessageLog(birthdayMessageLog);
}
}
protected void ResentMessengerButton_Click(object ob, EventArgs e)
{
string selectedItems = Request.Form["CheckBoxDelete"];
if (!string.IsNullOrEmpty(selectedItems))
{
foreach (string selectedItemId in selectedItems.Split(','))
{
MessageContent messageContent = new MessageContent();
messageContent = MessageContentService.GetMessageContentIDAndDate(Convert.ToInt32(selectedItemId), ApplicationHelper.ConvertStringToDate(this.FromDate.Text));
messageContent.Status = 0;
MessageContentService.UpdateMessageContent(messageContent);
}
this.UpdateInterface();
}
}
protected void Send_Click(object sender, EventArgs e)
{
if (this.templateDropDownList.SelectedValue == "0" || this.templateDropDownList.SelectedValue == string.Empty)
{
messageLiteral.Text = Resources.UIResource.InvalidTemplateContent;
messageLiteral.Visible = true;
return;
}
if (Page.IsValid == false)
return;
try
{
this.GetContentTemplate();
if (contentTemplate != null)
{
MessageContent messageContent = new MessageContent();
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
messageContent.BodyMessage = contentTemplate.BodyMessage;
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.CreatedDate = DateTime.Now;
messageContent.ModifiedDate = DateTime.Now;
messageContent.Receiver = this.receiverTextBox.Text;
messageContent.Sender = contentTemplate.Sender;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.Subject = contentTemplate.Subject;
if (contentTemplate.ServiceTypeID == 1)
{
VfsCustomerService.Business.SendTemplateEmailWithParam sendMail = new SendTemplateEmailWithParam();
contentTemplate.Receiver = this.receiverTextBox.Text;
sendMail.Send(contentTemplate);
}
else
{
SendSMS sendSMS = new SendSMS();
sendSMS.UserName = ApplicationHelper.SmsUserName;
sendSMS.Password = ApplicationHelper.SmsPassword;
sendSMS.Send(messageContent);
}
messageLiteral.Text = Resources.UIResource.MeesageSucessfullySent;
messageLiteral.Visible = true;
}
}
catch (Exception ex)
{
messageLiteral.Text = Resources.UIResource.SimulationError + " :" + ex.Message;
messageLiteral.Visible = true;
log4net.Util.LogLog.Error(ex.InnerException.Message);
}
}
void Log(CardModel card)
{
string playerName = Receiver.GetPlayerByKey(Invoker).Info.NickName;
string commandName = Receiver.GetCommandByKey(COMMANDCODE).Data.Name;
MessageContent logContent = new MessageContent(string.Concat("[", playerName, "] ", commandName, " "));
logContent.Add(CardLogger.EncodeCardSmartName(card));
Receiver.Console.WriteLog(logContent);
}
public static void CreateMessage(CustomerCollection data, string[] contentToBeSent, ContentTemplate contentTemplate, ref int numberCustomerSent)
{
int i = 0;
foreach (Customer item in data)
{
//shareHolder.ShareHolderCode = items[0];
if (item != null)
{
numberCustomerSent++;
MessageContent messageContent = null;
messageContent = new MessageContent();
messageContent.Sender = contentTemplate.Sender;
messageContent.Subject = contentTemplate.Subject;
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
messageContent.BodyMessage = ReplaceBodyMessage(contentTemplate.BodyMessage, contentToBeSent[i++]);
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
//in case the message is type of email check if the email address is valid
if (messageContent.ServiceTypeID == 1)
{
messageContent.Receiver = item.Email;
if (ValidateEmail(messageContent.Receiver) == true)
{
MessageContentService.CreateMessageContent(messageContent);
ContentTemplateAttachementCollection contentTemplateAttachementColl = ContentTemplateAttachementService.GetContentTemplateAttachementList(contentTemplate.ContentTemplateID, ContentTemplateAttachementColumns.ModifiedDate, "DESC");
foreach (ContentTemplateAttachement attachement in contentTemplateAttachementColl)
{
MessageContentAttachement messageContentAttachement = new MessageContentAttachement();
messageContentAttachement.AttachementDescription = attachement.AttachementDescription;
messageContentAttachement.AttachementDocument = attachement.AttachementDocument;
messageContentAttachement.MessageContentID = messageContent.MessageContentID;
messageContentAttachement.ModifiedDate = DateTime.Now;
messageContentAttachement.CreatedDate = DateTime.Now;
MessageContentAttachementService.CreateMessageContentAttachement(messageContentAttachement);
}
}
}
else
{
messageContent.Receiver = item.Mobile;
MessageContentService.CreateMessageContent(messageContent);
ContentTemplateAttachementCollection contentTemplateAttachementColl = ContentTemplateAttachementService.GetContentTemplateAttachementList(contentTemplate.ContentTemplateID, ContentTemplateAttachementColumns.ModifiedDate, "DESC");
foreach (ContentTemplateAttachement attachement in contentTemplateAttachementColl)
{
MessageContentAttachement messageContentAttachement = new MessageContentAttachement();
messageContentAttachement.AttachementDescription = attachement.AttachementDescription;
messageContentAttachement.AttachementDocument = attachement.AttachementDocument;
messageContentAttachement.MessageContentID = messageContent.MessageContentID;
messageContentAttachement.ModifiedDate = DateTime.Now;
messageContentAttachement.CreatedDate = DateTime.Now;
MessageContentAttachementService.CreateMessageContentAttachement(messageContentAttachement);
}
}
}
}
}
public WindowResponse ShowMessage(MessageContent content, object args)
{
WindowResponse res = WindowResponse.None;
switch (content)
{
case MessageContent.IsBusy:
SendInfoText(Message.GetString("LapseStudio is currently busy"));
break;
case MessageContent.SaveQuestion:
res = this.Show(Message.GetString("Do you want to save the current project?"), Message.GetString("Save Project?"), MessageWindowType.Question, MessageWindowButtons.YesNoCancel);
break;
case MessageContent.FramesAlreadyAdded:
SendInfoText(Message.GetString("Frames already added"));
break;
case MessageContent.BusyClose:
res = this.Show(Message.GetString("LapseStuio is currently busy. Do you want to close anyway?"), Message.GetString("Close LapseStudio?"), MessageWindowType.Question, MessageWindowButtons.YesNo);
break;
case MessageContent.BrightnessNotCalculatedError:
SendInfoText(Message.GetString("Brightness is not calculated yet"));
break;
case MessageContent.BrightnessNotCalculatedWarning:
res = this.Show(Message.GetString("Brightness is not calculated yet. Do you want to proceed anyway?"), Message.GetString("Proceed?"), MessageWindowType.Question, MessageWindowButtons.YesNo);
break;
case MessageContent.KeyframecountLow:
SendInfoText(Message.GetString("Not enough keyframes added"));
break;
case MessageContent.NotEnoughFrames:
SendInfoText(Message.GetString("Not enough frames loaded"));
break;
case MessageContent.ProjectSaved:
SendInfoText(Message.GetString("Project saved"));
break;
case MessageContent.RemoveMetadataLink:
res = this.Show(Message.GetString("Remove the link to the original metadata file?"), Message.GetString("Remove link?"), MessageWindowType.Question, MessageWindowButtons.YesNo);
break;
case MessageContent.UseReadXMP:
res = this.Show(Message.GetString("There is no XMP linked to this file.") + Environment.NewLine + Message.GetString("Do you want to try to exctract it from the file?"), Message.GetString("Search for XMP?"), MessageWindowType.Question, MessageWindowButtons.YesNo);
break;
case MessageContent.NotEnoughValidFiles:
this.Show(Message.GetString("Not enough valid images found for this kind of project."), MessageWindowType.Warning);
break;
case MessageContent.BrightnessAlreadyCalculated:
res = this.Show(Message.GetString("Brightness is already calculated. Do you want to calculate again?"), Message.GetString("Calculate Again?"), MessageWindowType.Question, MessageWindowButtons.YesNo);
break;
case MessageContent.KeyframeAdded:
SendInfoText(Message.GetString("Keyframe set!"));
break;
case MessageContent.KeyframeNotAdded:
SendInfoText(Message.GetString("Keyframe not set!"));
break;
default:
res = this.Show(Message.GetString("Something happened!") + Environment.NewLine + Message.GetString("(There is not more information available)"), MessageWindowType.Warning, MessageWindowButtons.Ok);
break;
}
return res;
}
public static void CreateMessage(string filePath, string fileName, ContentTemplate contentTemplate, NameValueCollection parameters, out Int32 successCount, out List<string[]> notImportedData)
{
string[] typicalHeaders = null;
string[] headers ;
List<string[]> data = null;
Hashtable hastableParameters = new Hashtable();
notImportedData = new List<string[]>();
successCount = 0;
try
{
ReadCvsHeader(filePath + fileName, out headers);
ReadCvsData(filePath + fileName, out headers, out data);
if (!ValidateHeaders(typicalHeaders, headers))
{
throw new InvalidDataException("CSV file is invalid format!");
}
foreach (string[] items in data)
{
//shareHolder.ShareHolderCode = items[0];
MessageContent messageContent = null;
messageContent = new MessageContent();
messageContent.Sender = contentTemplate.Sender;
Customer customer = null;
string customerId = items[0].Replace("K", "C");
customer = CustomerService.GetCustomer(customerId);
if (customer == null)
{
notImportedData.Add(items);
}
else
{
if (contentTemplate.ServiceTypeID == 1)
messageContent.Receiver = customer.Email;
else
messageContent.Receiver = customer.Mobile;
messageContent.Subject = contentTemplate.Subject;
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
hastableParameters = ConvertParametersToHastable(parameters);
messageContent.BodyMessage = ReplaceBodyMessage(contentTemplate.BodyMessage, hastableParameters, items);
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
if (contentTemplate.ServiceTypeID == 1)
{
if (ValidateEmail(messageContent.Receiver) == true)
{
MessageContentService.CreateMessageContent(messageContent);
ContentTemplateAttachementCollection contentTemplateAttachementColl = ContentTemplateAttachementService.GetContentTemplateAttachementList(contentTemplate.ContentTemplateID, ContentTemplateAttachementColumns.ModifiedDate, "DESC");
foreach (ContentTemplateAttachement attachement in contentTemplateAttachementColl)
{
MessageContentAttachement messageContentAttachement = new MessageContentAttachement();
messageContentAttachement.AttachementDescription = attachement.AttachementDescription;
messageContentAttachement.AttachementDocument = attachement.AttachementDocument;
messageContentAttachement.MessageContentID = messageContent.MessageContentID;
messageContentAttachement.ModifiedDate = DateTime.Now;
messageContentAttachement.CreatedDate = DateTime.Now;
MessageContentAttachementService.CreateMessageContentAttachement(messageContentAttachement);
}
successCount++;
}
}
else
{
MessageContentService.CreateMessageContent(messageContent);
ContentTemplateAttachementCollection contentTemplateAttachementColl = ContentTemplateAttachementService.GetContentTemplateAttachementList(contentTemplate.ContentTemplateID, ContentTemplateAttachementColumns.ModifiedDate, "DESC");
foreach (ContentTemplateAttachement attachement in contentTemplateAttachementColl)
{
MessageContentAttachement messageContentAttachement = new MessageContentAttachement();
messageContentAttachement.AttachementDescription = attachement.AttachementDescription;
messageContentAttachement.AttachementDocument = attachement.AttachementDocument;
messageContentAttachement.MessageContentID = messageContent.MessageContentID;
messageContentAttachement.ModifiedDate = DateTime.Now;
messageContentAttachement.CreatedDate = DateTime.Now;
MessageContentAttachementService.CreateMessageContentAttachement(messageContentAttachement);
}
successCount++;
}
}
}
if (File.Exists(filePath + fileName))
{
File.Delete(filePath + fileName);
}
}
catch (Exception ex)
{
// log this exception
log4net.Util.LogLog.Error(ex.Message, ex);
// wrap it and rethrow
throw new ApplicationException(SR.BusinessImport_CreateMessageWithEmailException, ex);
}
finally
{
if (data != null) data = null;
}
}
public static void CreateMessageWithEmail(Stream stream, string filePath, string fileName, ContentTemplate contentTemplate)
{
string[] typicalHeaders = {"Receiver"};
string[] headers;
List<string[]> data = null;
try
{
string uploadFileName = UploadService.UploadDocument(stream, filePath, fileName);
ReadCvsData(filePath + uploadFileName, out headers, out data);
if (!ValidateHeaders(typicalHeaders, headers))
{
throw new InvalidDataException("CSV file is invalid format!");
}
foreach (string[] items in data)
{
//shareHolder.ShareHolderCode = items[0];
MessageContent messageContent = null;
messageContent = new MessageContent();
messageContent.Sender = contentTemplate.Sender;
messageContent.Receiver = items[0];
messageContent.Subject = contentTemplate.Subject;
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
messageContent.BodyMessage = contentTemplate.BodyMessage;
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
MessageContentService.CreateMessageContent(messageContent);
ContentTemplateAttachementCollection contentTemplateAttachementColl = ContentTemplateAttachementService.GetContentTemplateAttachementList(contentTemplate.ContentTemplateID, ContentTemplateAttachementColumns.ModifiedDate, "DESC");
foreach (ContentTemplateAttachement attachement in contentTemplateAttachementColl)
{
MessageContentAttachement messageContentAttachement = new MessageContentAttachement();
messageContentAttachement.AttachementDescription = attachement.AttachementDescription;
messageContentAttachement.AttachementDocument = attachement.AttachementDocument;
messageContentAttachement.MessageContentID = messageContent.MessageContentID;
messageContentAttachement.ModifiedDate = DateTime.Now;
messageContentAttachement.CreatedDate = DateTime.Now;
MessageContentAttachementService.CreateMessageContentAttachement(messageContentAttachement);
}
}
if (File.Exists(filePath + uploadFileName))
{
File.Delete(filePath + uploadFileName);
}
}
catch (Exception ex)
{
// log this exception
log4net.Util.LogLog.Error(ex.Message, ex);
// wrap it and rethrow
throw new ApplicationException(SR.BusinessImport_CreateMessageWithEmailException, ex);
}
finally
{
if (data != null) data = null;
}
}
public SendEmailException(MessageContent email, Exception innerException)
: base("", innerException)
{
emailException = email;
}
public static void CreateMessageWithEmailEncrypt(string[] data, ContentTemplate contentTemplate, ref int numberCustomerSent)
{
SimpleAES encryptEmail = new SimpleAES();
foreach (string item in data)
{
//shareHolder.ShareHolderCode = items[0];
if (item != string.Empty && item != null)
{
numberCustomerSent++;
MessageContent messageContent = null;
messageContent = new MessageContent();
messageContent.Sender = contentTemplate.Sender;
messageContent.Receiver = item;
messageContent.Subject = contentTemplate.Subject;
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
messageContent.BodyMessage = contentTemplate.BodyMessage.Replace("$#email#", encryptEmail.EncryptToString(item));
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
MessageContentService.CreateMessageContent(messageContent);
ContentTemplateAttachementCollection contentTemplateAttachementColl = ContentTemplateAttachementService.GetContentTemplateAttachementList(contentTemplate.ContentTemplateID, ContentTemplateAttachementColumns.ModifiedDate, "DESC");
foreach (ContentTemplateAttachement attachement in contentTemplateAttachementColl)
{
MessageContentAttachement messageContentAttachement = new MessageContentAttachement();
messageContentAttachement.AttachementDescription = attachement.AttachementDescription;
messageContentAttachement.AttachementDocument = attachement.AttachementDocument;
messageContentAttachement.MessageContentID = messageContent.MessageContentID;
messageContentAttachement.ModifiedDate = DateTime.Now;
messageContentAttachement.CreatedDate = DateTime.Now;
MessageContentAttachementService.CreateMessageContentAttachement(messageContentAttachement);
}
}
}
}
public static string SendInValidResponseMessage(string UserID, string ServiceID, string CommandCode, string Message, string RequestID, string MoID, string Username, string Password, Int32 invalidSMSContentTemplateId)
{
string returnValue = "1";
// int result;
try
{
IncomingMessageContent incomingMessageContent = new IncomingMessageContent();
incomingMessageContent.ServiceTypeID = 2;
incomingMessageContent.CommandCode = CommandCode;
incomingMessageContent.ServiceID = ServiceID;
incomingMessageContent.Sender = UserID;
incomingMessageContent.MoID = MoID;
incomingMessageContent.CreatedDate = DateTime.Now;
incomingMessageContent.ModifiedDate = DateTime.Now;
incomingMessageContent.BodyMessage = Message;
incomingMessageContent.Request = RequestID;
incomingMessageContent.BodyContentType = "PlainText";
incomingMessageContent.BodyEncoding = "UTF-8";
incomingMessageContent.Status = 0;
IncomingMessageContentService.CreateIncomingMessageContent(incomingMessageContent);
ContentTemplate contentTemplate = null;
contentTemplate = ContentTemplateService.GetContentTemplate(invalidSMSContentTemplateId);
MessageContent messageContent = null;
if (contentTemplate != null)
{
messageContent = new MessageContent();
messageContent.Sender = contentTemplate.Sender;
messageContent.Receiver = UserID;
messageContent.Subject = contentTemplate.Subject;
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
messageContent.BodyMessage = contentTemplate.BodyMessage;
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
messageContent.Request = RequestID;
messageContent.MoID = MoID;
messageContent.ServiceID = ServiceID;
messageContent.CommandCode = CommandCode;
}
MessageContentService.CreateMessageContent(messageContent);
return returnValue;
}
catch (ApplicationException)
{
throw;
}
catch (Exception ex)
{
// log this exception
log4net.Util.LogLog.Error(ex.Message, ex);
// wrap it and rethrow
throw new ApplicationException(SR.BusinessSendSMSToCoreSecuritiesException, ex);
}
}
public void WriteLog(MessageContent content)
{
Messages.Add(new TextMessage(MessageCategory.Log, content));
}
public static string SendMessage(string UserID, string ServiceID, string CommandCode, string Message, string RequestID, string MoID, string Username, string Password, Int32 transferMoneyContentTemplateId, string email)
{
string returnValue = "1";
int result;
try
{
IncomingMessageContent incomingMessageContent = new IncomingMessageContent();
incomingMessageContent.ServiceTypeID = 2;
incomingMessageContent.CommandCode = CommandCode;
incomingMessageContent.ServiceID = ServiceID;
incomingMessageContent.Sender = UserID;
incomingMessageContent.MoID = MoID;
incomingMessageContent.CreatedDate = DateTime.Now;
incomingMessageContent.ModifiedDate = DateTime.Now;
incomingMessageContent.BodyMessage = Message;
incomingMessageContent.Request = RequestID;
incomingMessageContent.BodyContentType = "PlainText";
incomingMessageContent.BodyEncoding = "UTF-8";
incomingMessageContent.Status = 0;
IncomingMessageContentService.CreateIncomingMessageContent(incomingMessageContent);
SendEmail sendMail = new SendEmail();
sendMail.Sender = ContentParameterService.GetContentParameter(1).ContentParameterValue;
sendMail.Receiver = email;
sendMail.Subject = "Dich Vu chuyen tien:" + UserID;
sendMail.SmtpServer = ContentParameterService.GetContentParameter(4).ContentParameterValue;
sendMail.IsHtmlMail = true;
sendMail.BodyText = "Yeu cau thuc hien dich vu chuyen tien cua: " + UserID + "<br />" + Message;
bool success = Int32.TryParse(ContentParameterService.GetContentParameter(5).ContentParameterValue, out result);
if (success == true)
{
sendMail.SmtpPort = result;
}
sendMail.Send();
ContentTemplate contentTemplate = null;
contentTemplate = ContentTemplateService.GetContentTemplate(transferMoneyContentTemplateId);
MessageContent messageContent = null;
if (contentTemplate != null)
{
messageContent = new MessageContent();
messageContent.Sender = contentTemplate.Sender;
messageContent.Receiver = UserID;
messageContent.Subject = contentTemplate.Subject;
messageContent.BodyContentType = contentTemplate.BodyContentType;
messageContent.BodyEncoding = contentTemplate.BodyEncoding;
messageContent.BodyMessage = contentTemplate.BodyMessage;
messageContent.ContentTemplateID = contentTemplate.ContentTemplateID;
messageContent.ServiceTypeID = contentTemplate.ServiceTypeID;
messageContent.ModifiedDate = DateTime.Now;
messageContent.CreatedDate = DateTime.Now;
messageContent.Status = 0;
messageContent.Request = RequestID;
messageContent.MoID = MoID;
messageContent.ServiceID = ServiceID;
messageContent.CommandCode = CommandCode;
}
MessageContentService.CreateMessageContent(messageContent);
return returnValue;
}
catch (ApplicationException)
{
throw;
}
catch (Exception ex)
{
// log this exception
log4net.Util.LogLog.Error(ex.Message, ex);
// wrap it and rethrow
throw new ApplicationException(SR.BusinessSendSMSToCoreSecuritiesException, ex);
}
}
public void WriteLine(MessageCategory category, MessageContent content)
{
Messages.Add(new TextMessage(category, content));
}
