/// <summary>
/// Выполнение метода с заданными аргументами
/// </summary>
/// <param name="methodArgs"></param>
public async virtual Task ExecuteAsync(BotActivity bot, SendMessageArgs args)
{
//Type typeOfFS = typeof(FunctionsStorage);
//var method = typeOfFS.GetMethod(MethodName);
//if (method != null)
// method.Invoke(null, methodArgs);
}
public async override Task ExecuteAsync(BotActivity bot, SendMessageArgs args)
{
args.Answer = Arguments[0];
await WriteInStorage(bot.MasterId, args.AuthorId, Arguments[1].ToString(), args.Message);
await bot.SendTextMessageAsync(args);
}
public void SendEmail(SendMessageArgs args)
{
var mailRepo = Impl.Mail.MailRepo.Create(_conn, _tx);
int messageId = mailRepo.InsertMessage(args.ClientID, args.Caller, args.From, args.Subject, args.Body);
if (messageId == 0)
{
throw new Exception("Failed to create message [messageId = 0]");
}
mailRepo.InsertRecipients(messageId, AddressType.To, args.To);
mailRepo.InsertRecipients(messageId, AddressType.Cc, args.Cc);
mailRepo.InsertRecipients(messageId, AddressType.Bcc, args.Bcc);
try
{
Impl.Mail.MailUtility.Send(args);
mailRepo.SetMessageSent(messageId);
}
catch (Exception ex)
{
mailRepo.SetMessageError(messageId, ex.Message);
throw ex;
}
}
public async override Task ExecuteAsync(BotActivity bot, SendMessageArgs args)
{
args.Answer = "типа данные";
await bot.SendTextMessageAsync(new SendMessageArgs()
{
Answer = await GetDataFromStorage(bot.MasterId, Arguments[0].ToString()), ChatId = args.ChatId
});
}
public void SendedMessage(object source, SendMessageArgs e)
{
this.Dispatcher.Invoke(() =>
{
String oldMessage = textboxMessage.Text.ToString();
textboxMessage.Text = oldMessage + e.message + "\n";
});
}
public void SendMessage(SendMessageArgs args)
{
var content = Post("webapi/mail/send/message", args);
var errmsg = JsonConvert.DeserializeObject(content).ToString();
if (!string.IsNullOrEmpty(errmsg))
{
throw new Exception(errmsg);
}
}
public void SendedMessagePrivateChat(object source, SendMessageArgs e)
{
this.Dispatcher.Invoke(() =>
{
String oldMessage = textbox1.Text.ToString();
textbox1.Text = oldMessage + e.message + "\n";
textbox2.Clear();
});
}
public async void SendMessageAsync(object sender, SendMessageArgs args)
{
var context = sender as SocketCommandContext;
if (context == null)
{
return;
}
await context.Channel.SendMessageAsync(args.Message);
}
public async override Task SendTextMessageAsync(SendMessageArgs args)
{
if (!String.IsNullOrWhiteSpace(args.Answer))
{
await Client.SendTextMessageAsync(args.ChatId, args.Answer, Telegram.Bot.Types.Enums.ParseMode.Html);
}
if (!String.IsNullOrWhiteSpace(args.Photo))
{
await Client.SendPhotoAsync(args.ChatId, new Telegram.Bot.Types.InputFiles.InputOnlineFile(File.OpenRead(AppConfig.UsersPath + "/" + MasterId + "/files/images/" + args.Photo)));
}
}
public void Process(SendMessageArgs args)
{
// NOTE [ILs] The actual EDS core message that will be dispatched is hidden in custom data
if (args.CustomData["EmailMessage"] is EmailMessage email)
{
if (email.Headers.AllKeys.Contains(Constants.SenderField))
{
email.Headers[Constants.SenderField] = "\"Automated System\" <*****@*****.**>";
}
}
}
public async Task SendMessage(SendMessageArgs args)
{
//Load data from database based on args
var membership = await ChatContext.Membership
.Include(m => m.ChatUser)
.Include(m => m.Group)
.ThenInclude(g => g.ChatMessages)
.Include(m => m.Group)
.ThenInclude(g => g.Memberships)
.FirstOrDefaultAsync(m => m.MembershipID == args.MembershipID);
if (!ValidateUser(membership.ChatUser))
{
return;
}
ChatUser sender = membership.ChatUser;
Group group = membership.Group;
//Log the message
ChatMessage chatMessage = await ProcessMessageAsync(membership, args.Message, args.Multimedia);
group.ChatMessages.Add(chatMessage);
await ChatContext.SaveChangesAsync();
//Distribute the message
List <string> list = new List <string>();
foreach (var m in group.Memberships)
{
if (m.IsOnlineInGroup)
{
if (m.IsActiveInGroup)
{
m.LastViewedMessageID = chatMessage.ChatMessageID;
}
list.Add(m.ChatUserID + "");
}
else
{
m.NumNew++;
}
}
await ChatContext.SaveChangesAsync();
await Clients.Users(list)
.SendAsync(
"ReceiveMessage",
await GetArgsFromChatMessageAsync(chatMessage, sender, membership));
}
// override the abstract OnCommand method. This method is called by the scripted OrbServer class
public override void OnCommand(OrbClientInfo clientInfo, OrbCommandArgs args)
{
// cast the clientInfo into the OrbClientState subclass that contains addition info
// such as the OrbClientID, Account, and logged in char if online.
OrbClientState client = (OrbClientState)clientInfo;
// cast the args to the appropriate subclass
SendMessageArgs msgArgs = (SendMessageArgs)args;
if (client.OnlineMobile != null)
{
// send the message to the logged in character
client.OnlineMobile.SendMessage(msgArgs.Message);
}
}
public void Process(SendMessageArgs args)
{
// NOTE [ILs] This is the message Sitecore item wrapped for easy access to various details
MailMessageItem message = args.EcmMessage as MailMessageItem;
if (_attachToMessageIdList.Contains(message?.InnerItem.ID))
{
// NOTE [ILs] The actual EDS core message that will be dispatched is hidden in custom data
if (args.CustomData["EmailMessage"] is EmailMessage email)
{
FileResource attachment = GenerateAttachment(message);
email.Attachments.Add(attachment);
}
}
}
public static MailAddress GetFromAddress(SendMessageArgs args)
{
MailAddress result;
if (!string.IsNullOrEmpty(args.DisplayName))
{
result = new MailAddress(args.From, args.DisplayName);
}
else
{
result = new MailAddress(args.From);
}
return(result);
}
public void Process(SendMessageArgs args)
{
if (!(args.EcmMessage is MessageItem message))
{
return;
}
if (!message.CustomPersonTokens.ContainsKey(Constants.CustomTokensFormKey))
{
return;
}
var formFields = message.CustomPersonTokens[Constants.CustomTokensFormKey];
if (formFields == null)
{
return;
}
message.CustomPersonTokens[Constants.CustomTokensFormKey] = ConvertToPlainText(formFields);
}
public void Process(SendMessageArgs args)
{
//If the message is a SMS, we send it here, otherwise we let base handle
var sms = args.EcmMessage as SMSMessageType;
if (sms == null)
{
base.Process(args);
return;
}
//It's an SMS
var message = args.CustomData["EmailMessage"] as EmailMessage;
if (message.Recipients.Count < 1)
{
args.AddMessage("Missing Recipients from EmailMessage argument.");
return;
}
args.StartSendTime = DateTime.UtcNow;
var from = message.Subject;
var phoneNumber = sms.PersonalizationRecipient.Identifiers.FirstOrDefault(x => x.Source == "mobile").Identifier;
var text = WebUtility.HtmlDecode(message.PlainTextBody);
try
{
//TODO: DI this.
var service = new SMSService();
service.SendSMS(phoneNumber, text);
//DO STUFF IN HERE TO SEND SMS
base.Process(args);
}
catch (Exception ex)
{
throw new NonCriticalException(ex.Message, ex);
}
args.AddMessage("ok", PipelineMessageType.Information);
args.SendingTime = Util.GetTimeDiff(args.StartSendTime, DateTime.UtcNow);
}
private SendMessageArgs CreateArgs(string caller, string subject, string body, string to, params string[] cc)
{
var fromEmail = GetSystemEmail();
var args = new SendMessageArgs()
{
Caller = caller,
ClientID = Context.CurrentUser.ClientID,
From = fromEmail,
DisplayName = "LNF Ordering",
To = new[] { GetToEmail(to) },
Cc = GetCcEmail(cc),
Subject = subject,
Body = body,
IsHtml = true
};
return(args);
}
public void Process(SendMessageArgs args)
{
if (!(args.EcmMessage is MessageItem ecmmessage))
{
return;
}
if (!(args.CustomData["EmailMessage"] is EmailMessage message))
{
args.AddMessage("Missing EmailMessage from arguments.");
return;
}
foreach (var attachmentReference in ecmmessage.CustomPersonTokens.Keys.Where(k => k.StartsWith("attachment_")))
{
var storedFileJSon = ecmmessage.CustomPersonTokens[attachmentReference].ToString();
var storedFileFromToken = JsonConvert.DeserializeObject <StoredFileInfo>(storedFileJSon);
var storedFile = fileStorageProvider.GetFile(storedFileFromToken.FileId);
var fileContent = GetStreamAsByteArray(storedFile.File);
message.Attachments.Add(new FileResource(storedFile.FileInfo.FileName, fileContent));
}
}
public static void Send(SendMessageArgs args)
{
using (var smtp = GetSmtpClient())
using (var mm = new MailMessage {
From = GetFromAddress(args)
})
{
AddAddresses(mm.To, args.To);
AddAddresses(mm.CC, args.Cc);
AddAddresses(mm.Bcc, args.Bcc);
mm.Subject = args.Subject;
mm.Body = args.Body;
mm.IsBodyHtml = args.IsHtml;
AddAttachments(mm.Attachments, args.Attachments);
smtp.Send(mm);
}
}
public void Process(SendMessageArgs args)
{
if (!(args.EcmMessage is MessageItem ecmmessage))
{
return;
}
if (!(args.CustomData["EmailMessage"] is EmailMessage message))
{
args.AddMessage("Missing EmailMessage from arguments.");
return;
}
foreach (var attachmentReference in ecmmessage.CustomPersonTokens.Keys.Where(k =>
k.StartsWith("attachment_")))
{
var storedFileJson = ecmmessage.CustomPersonTokens[attachmentReference].ToString();
var storedFile = JsonConvert.DeserializeObject <StoredFile>(storedFileJson);
var fileUploadStorageProvider = fileUploadStorageProviderFactory.GetDefaultFileUploadStorageProvider();
var fileContent = fileUploadStorageProvider.GetFileAsBytes(storedFile);
message.Attachments.Add(new FileResource(storedFile.OriginalFileName, fileContent));
}
}
private void CreateMessageFragmentViewModel_OnMessageSent(object sender, SendMessageArgs e)
{
Toast.MakeText(Activity, e.response, ToastLength.Long).Show();
}
public override Task SendTextMessageAsync(SendMessageArgs args)
{
throw new NotImplementedException();
}
public static void OnSendMessageEvent(object sender, SendMessageArgs args)
{
var handler = SendMessageEvent;
handler?.Invoke(sender, args);
}
public string SendMessage([FromBody] SendMessageArgs args)
{
// returing any non-empty string means an error occured
Provider.Mail.SendMessage(args);
return(string.Empty);
}
public SendMessageArgs CreateSendMessageArgs(MassEmailSendArgs args)
{
if (string.IsNullOrEmpty(args.Group))
{
throw new Exception("Group must not be null or empty.");
}
if (args.Values == null || args.Values.Count() == 0)
{
throw new Exception("Values must not be null or empty.");
}
if (string.IsNullOrEmpty(args.Caller))
{
throw new Exception("Caller is required.");
}
if (string.IsNullOrEmpty(args.From))
{
throw new Exception("From address is required.");
}
if (string.IsNullOrEmpty(args.DisplayName))
{
throw new Exception("Display name is required.");
}
if (string.IsNullOrEmpty(args.Subject))
{
throw new Exception("Subject is required.");
}
if (string.IsNullOrEmpty(args.Body))
{
throw new Exception("Body is required.");
}
// an array of file paths
var attachments = GetAttachments(args.Attachments);
var gs = GlobalSettings.Current;
string footer = "\n\n--------------------------------------------------\nThis email has been sent to the following group(s) : " + GetGroup(args) + ".";
footer += $"\nYou are receiving this email message because you are associated with the {gs.CompanyName}.\nTo unsubscribe, please go to:\nhttp://ssel-sched.eecs.umich.edu/sselonline/Unsubscribe.aspx";
SendMessageArgs sma = new SendMessageArgs
{
ClientID = args.ClientID,
Caller = args.Caller,
Subject = args.Subject,
Body = args.Body + footer,
From = args.From,
DisplayName = args.DisplayName,
Attachments = attachments,
IsHtml = false
};
var recipients = new List <MassEmailRecipient>();
var mgr = new GroupEmailManager(Session);
switch (args.Group)
{
case Groups.Privilege:
recipients.AddRange(mgr.GetEmailListByPrivilege(Combine(args.Values)));
break;
case Groups.Community:
recipients.AddRange(mgr.GetEmailListByCommunity(Combine(args.Values)));
break;
case Groups.Manager:
recipients.AddRange(mgr.GetEmailListByManagerID(args.Values.First()));
break;
case Groups.Tools:
recipients.AddRange(mgr.GetEmailListByTools(args.Values.ToArray()));
break;
case Groups.InLab:
recipients.AddRange(mgr.GetEmailListByInLab(args.Values.ToArray()));
break;
default:
throw new NotImplementedException($"Unknown group: {args.Group}");
}
if (recipients.Count > 0)
{
var to = new List <string>();
var cc = new List <string>();
var bcc = new List <string>();
int staffCount = 0;
int totalCount = 0;
foreach (var recip in recipients)
{
if (recip.IsStaff)
{
// we have to expose staff member's emails, so adding to To (not Bcc)
AddRecipient(to, recip.Email);
staffCount++;
}
else
{
AddRecipient(bcc, recip.Email);
}
totalCount++;
}
if (!string.IsNullOrEmpty(args.CC))
{
AddRecipients(cc, args.CC.Split(','));
}
IClient client = Client.GetClient(args.ClientID);
bool isStaff = client.HasPriv(ClientPrivilege.Staff);
bool recipientsIncludeNonStaff = staffCount != totalCount;
if (isStaff && recipientsIncludeNonStaff)
{
// messages only sent here if staff is sending email to non-staff
AddRecipient(bcc, "*****@*****.**");
}
// all messages are sent here
AddRecipient(bcc, "*****@*****.**");
// apparently we always send to the from address also
AddRecipient(to, args.From);
sma.To = to.Count == 0 ? null : to;
sma.Bcc = bcc.Count == 0 ? null : bcc;
sma.Cc = cc.Count == 0 ? null : cc;
}
return(sma);
}
public string Post([FromBody] SendMessageArgs args)
{
ServiceProvider.Current.Mail.SendMessage(args);
return("message sent ok");
}
