private static MessageRule BuildMailRule(string displayName, int sequence, bool isEnabled, string senderContains, string forwardToEmail)
{
IEnumerable <string> senderContainsList = new string[] { senderContains };
EmailAddress email = new EmailAddress()
{
Address = forwardToEmail
};
Recipient recipient = new Recipient()
{
EmailAddress = email
};
IEnumerable <Recipient> recipientList = new Recipient[] { recipient };
var msgRule = new MessageRule {
DisplayName = displayName,
Sequence = sequence,
IsEnabled = isEnabled,
Conditions = new MessageRulePredicates {
SenderContains = senderContainsList
},
Actions = new MessageRuleActions {
ForwardTo = recipientList
}
};
return(msgRule);
}
public void Test_MessageRuleDeserialization()
{
string messageRuleDefinition = @"
{
""id"": ""AQAAAJBPvO0="",
""displayName"": ""09457c9f-1393-470d-aeb5-8075be93f8f4"",
""sequence"": 1,
""isEnabled"": true,
""hasError"": false,
""isReadOnly"": false,
""conditions"": {
""senderContains"": [
""TESTUSER""
]
},
""actions"": {
""stopProcessingRules"": true,
""forwardTo"": [
{
""emailAddress"": {
""name"": ""*****@*****.**"",
""address"": ""*****@*****.**""
}
}
]
}
}";
MessageRule messageRule = this.Convert <MessageRule>(messageRuleDefinition);
}
public JsonResult AddMessageNew(string AcceptIDS, string Title, string Content)
{
AjaxResult result = new AjaxResult();
Message msg = new Message();
msg.Content = Content;
msg.Title = Title;
try
{
MessageRule msgR = new MessageRule();
if (string.IsNullOrEmpty(msg.ID)) //新增
{
msg.ID = Guid.NewGuid().ToString("N");
msg.OperatorID = MyTicket.CurrentTicket.UserID;
msg.CreateDate = DateTime.Now;
msgR.Add(msg);
//不选接收人，默认发送给所有人
if (string.IsNullOrEmpty(AcceptIDS))
{
List <Ajax.Model.Customer> acceptList = new CustomerRule().GetList("");
foreach (Ajax.Model.Customer c in acceptList)
{
AcceptIDS += c.OperatorID + ",";
}
}
string[] strAcceptIDs = AcceptIDS.Remove(AcceptIDS.Length - 1, 1).Split(','); //Request.Form["txtAcceptIDs"].Split(',');
//接收人
OperatorMsgRule omsgR = new OperatorMsgRule();
List <OperatorMsg> oMsgList = new List <OperatorMsg>();
foreach (string acceptID in strAcceptIDs)
{
if (string.IsNullOrEmpty(acceptID))
{
continue;
}
OperatorMsg omsg = new OperatorMsg();
omsg.ID = Guid.NewGuid().ToString("N");
omsg.Status = 0; //默认为未读
omsg.MsgID = msg.ID;
omsg.OperatorID = acceptID;
oMsgList.Add(omsg);
}
omsgR.AddMul(oMsgList);
result.Success = true;
result.Message = "公告已经成功发出。";
}
else //编辑
{
result.Success = msgR.Update(msg);
result.Message = result.Success ? "公告已经成功修改。" : "公告修改失败！";
}
}
catch (Exception ex)
{
result.Success = false;
result.Message = "操作失败：" + ex.Message;
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 加载最近10条公告
/// </summary>
/// <returns></returns>
public ActionResult LoadSystemMsg()
{
if (MyTicket.CurrentTicket == null)
{
return(new HomeController().Login());
}
var showList = new MessageRule().GetLatestMsg(10, MyTicket.CurrentTicket.UserID);
return(Json(showList, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// CRUD operations for Inbox rules.
/// </summary>
/// <param name="exchangeService">Exchange service.</param>
public static async System.Threading.Tasks.Task CreateReadUpdateDeleteInboxRuleAsync(ExchangeService exchangeService)
{
MessageRule messageRule = new MessageRule(exchangeService);
messageRule.IsEnabled = true;
messageRule.Sequence = 1;
messageRule.Actions = new MessageRuleActions()
{
Delete = true,
StopProcessingRules = true
};
messageRule.Conditions = new MessageRulePredicates()
{
FromAddresses = new List <Recipient>()
{
new Recipient()
{
EmailAddress = new EmailAddress()
{
Address = "*****@*****.**"
}
}
}
};
messageRule.DisplayName = "Test rule";
Assert.IsNull(messageRule.Id);
await messageRule.SaveAsync();
Assert.IsNotNull(messageRule.Id);
Assert.IsNotNull(messageRule.Id);
MessageRule getMessageRule = await exchangeService.GetInboxRuleAsync(messageRule.Id);
Assert.IsNotNull(getMessageRule);
getMessageRule.IsEnabled = false;
await getMessageRule.UpdateAsync();
Assert.IsFalse(getMessageRule.IsEnabled);
List <MessageRule> rules = await exchangeService.GetInboxRulesAsync();
Assert.IsTrue(rules.Count == 1);
await getMessageRule.DeleteAsync();
rules = await exchangeService.GetInboxRulesAsync();
Assert.IsTrue(rules.Count == 0);
}
public async Task <MessageRule> Edit(MessageRule model)
{
var isUpdated = await _messageRuleRepository.Update(model);
if (isUpdated)
{
return(await _messageRuleRepository.Read(model.Id));
}
throw new Exception($"Failed to update message rule {model.Id}");
}
/// <summary>
/// CRUD operations for Inbox rules.
/// </summary>
/// <param name="exchangeService">Exchange service.</param>
public static void CreateReadUpdateDeleteInboxRule(ExchangeService exchangeService)
{
MessageRule messageRule = new MessageRule(exchangeService);
messageRule.IsEnabled = true;
messageRule.Sequence = 1;
messageRule.Actions = new MessageRuleActions()
{
Delete = true,
StopProcessingRules = true
};
messageRule.Conditions = new MessageRulePredicates()
{
FromAddresses = new List <Recipient>()
{
new Recipient()
{
EmailAddress = new EmailAddress()
{
Address = "*****@*****.**"
}
}
}
};
IList <string> s = new ObservableCollection <string>();
messageRule.DisplayName = "Test rule";
Assert.IsNull(messageRule.Id);
messageRule.Save();
Assert.IsNotNull(messageRule.Id);
Assert.IsNotNull(messageRule.Id);
MessageRule getMessageRule = exchangeService.GetInboxRule(messageRule.Id);
Assert.IsNotNull(getMessageRule);
getMessageRule.IsEnabled = false;
getMessageRule.Update();
Assert.IsFalse(getMessageRule.IsEnabled);
List <MessageRule> rules = exchangeService.GetInboxRules();
Assert.IsTrue(rules.Count == 1);
getMessageRule.Delete();
rules = exchangeService.GetInboxRules();
Assert.IsTrue(rules.Count == 0);
}
/// <summary>
/// https://adventofcode.com/2020/day/19#part2
/// </summary>
public static void Part2()
{
var groups = Input.GetGroups(19);
var ruleSet = MessageRuleSet.Parse(groups[0]);
var inputs = groups[1].Split('\n');
ruleSet[8] = MessageRule.Parse("42 | 42 8");
ruleSet[11] = MessageRule.Parse("42 31 | 42 11 31");
var count = inputs.Count(ruleSet[0].Matches);
Console.WriteLine(count);
}
public JsonResult DeleteMsg()
{
string[] msgIDs = Request.Form["msgIDs"].Split(',');
try
{
bool flag1 = new MessageRule().DeleteMul(new List <string>(msgIDs));
//bool flag2 = new OperatorMsgRule().DeleteMul(new List<string>(msgIDs));
}
catch
{
return(Json("公告删除失败！", JsonRequestBehavior.AllowGet));
}
return(Json("公告删除成功.", JsonRequestBehavior.AllowGet));
}
public string ParseMessage(string line, MessageRule rule)
{
line = ApplyAnchors(line, rule.GeneralRule.StartAnchor, rule.GeneralRule.EndAnchor);
var parsedValue = rule.GeneralRule.Matcher.Match(line);
if (!parsedValue.Success)
{
throw new ArgumentException(
$"Could not apply matcher '{rule.GeneralRule.Matcher}' to line '{line}' to extract message");
}
return(parsedValue.Value);
}
public void Test_MessageRuleEntityPath()
{
MessageRule rule = new MessageRule()
{
Id = "abc"
};
EntityPath entityPath = new EntityPath(rule);
Assert.IsFalse(entityPath.IsRootContainer);
Assert.AreEqual("MailFolders/Inbox/MessageRules", entityPath.RootContainer);
Assert.AreEqual("abc", entityPath.Id);
Assert.AreEqual("MailFolders/Inbox/MessageRules/abc", entityPath.Path);
Assert.IsNull(entityPath.SubEntity);
}
/// <summary>
/// Create new navigation property to messageRules for users
/// <param name="body"></param>
/// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
/// </summary>
public RequestInformation CreatePostRequestInformation(MessageRule body, Action<MessageRulesRequestBuilderPostRequestConfiguration> requestConfiguration = default) {
_ = body ?? throw new ArgumentNullException(nameof(body));
var requestInfo = new RequestInformation {
HttpMethod = Method.POST,
UrlTemplate = UrlTemplate,
PathParameters = PathParameters,
};
requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
if (requestConfiguration != null) {
var requestConfig = new MessageRulesRequestBuilderPostRequestConfiguration();
requestConfiguration.Invoke(requestConfig);
requestInfo.AddRequestOptions(requestConfig.Options);
requestInfo.AddHeaders(requestConfig.Headers);
}
return requestInfo;
}
public JsonResult Search(EasyUIGridParamModel gridParam, int status)
{
int itemCount = 0;
MessageRule msgR = new MessageRule();
List <dynamic> list = msgR.GetSearchJson(gridParam, status, MyTicket.CurrentTicket.UserID, out itemCount);
var listResult = from m in list
select new
{
ID = m.ID,
TITLE = "<a >" + m.TITLE + "</a>",
CREATEDATE = m.CREATEDATE,
STATUS = m.STATUS,
VIEW = "<b class='btnView'>查看</b>"
};
return(Json(new { total = itemCount, rows = listResult }, JsonRequestBehavior.AllowGet));
}
public void Part2Test()
{
// Given
var groups = Input.GetGroups(19, "Part2");
var ruleSet = MessageRuleSet.Parse(groups[0]);
var inputs = groups[1].Split('\n');
// When
var oldCount = inputs.Count(ruleSet[0].Matches);
ruleSet[8] = MessageRule.Parse("42 | 42 8");
ruleSet[11] = MessageRule.Parse("42 31 | 42 11 31");
var newCount = inputs.Count(ruleSet[0].Matches);
// Then
Assert.Equal(3, oldCount);
Assert.Equal(12, newCount);
}
public NormalizedLog ParseAll(string line, DateTimeRule dateTimeRule, SeverityRule severityRule,
MessageRule messageRule, IEnumerable <GeneralRule> customAttributeRules)
{
var dateTime = ParseDateTime(line, dateTimeRule);
var severity = ParseSeverityLevel(line, severityRule);
var message = ParseMessage(line, messageRule);
var customAttributes = new List <CustomAttributeValue>();
foreach (var customAttributeRule in customAttributeRules)
{
var result = ParseCustomAttribute(line, customAttributeRule);
customAttributes.Add(new CustomAttributeValue
{
GeneralRule = customAttributeRule, Id = 0, Value = result,
CustomAttributeRuleId = customAttributeRule.Id
});
}
// TODO check this
return(new NormalizedLog(dateTime, severity, message, 0, 0, 0, customAttributes.ToArray()));
}
public ICustomActivityResult Execute()
{
DataTable dt = new DataTable("resultSet");
dt.Columns.Add("Result");
MessageRulePredicates condition = new MessageRulePredicates();
MessageRuleActions actions = new MessageRuleActions();
GraphServiceClient client = new GraphServiceClient("https://graph.microsoft.com/v1.0", GetProvider());
var user = client.Users[userEmail];
var rules = user.MailFolders["Inbox"].MessageRules.Request().GetAsync().Result;
if (rules.Where(r => r.DisplayName.ToLower() == ruleDisplayName.ToLower()).FirstOrDefault() != null)
{
throw new Exception(string.Format("Rule with name '{0}' already exist", ruleDisplayName));
}
var messageRule = new MessageRule
{
DisplayName = ruleDisplayName,
IsEnabled = true
};
if (!string.IsNullOrEmpty(senderContains))
{
condition.SenderContains = new List <string>()
{
senderContains
};
}
if (!string.IsNullOrEmpty(bodyContains))
{
condition.BodyContains = new List <string>()
{
bodyContains
};
}
if (forwardAction)
{
if (string.IsNullOrEmpty(forwardEmail))
{
throw new Exception("forwardEmail field must be populated when forwardAction is set to True");
}
actions.ForwardTo = new List <Recipient>()
{
new Recipient
{
EmailAddress = new EmailAddress
{
Address = forwardEmail
}
}
};
}
else if (deleteAction)
{
actions.Delete = true;
}
if (string.IsNullOrEmpty(user.Request().GetAsync().Result.UsageLocation))
{
this.UpdateUser(user);
}
messageRule.Conditions = condition;
messageRule.Actions = actions;
messageRule.Actions.StopProcessingRules =
messageRule.IsEnabled = true;
messageRule.Sequence = rules.Count + 1;
user.MailFolders["Inbox"].MessageRules.Request().AddAsync(messageRule).Wait();
dt.Rows.Add(messageRule.Id);
return(this.GenerateActivityResult(dt));
}
public async Task <MessageRule> Create(MessageRule model)
{
var createdId = await _messageRuleRepository.Create(model);
return(await _messageRuleRepository.Read(createdId));
}
/// <summary>
/// MessageRule CRUD operation.
/// </summary>
/// <param name="exchangeService"></param>
/// <returns></returns>
public static async Task CreateReadUpdateDeleteMessageRule(ExchangeService exchangeService)
{
string ruleName = Guid.NewGuid().ToString();
MessageRule rule = new MessageRule(exchangeService);
rule.DisplayName = ruleName;
rule.Sequence = 1;
rule.IsEnabled = true;
rule.Conditions = new MessageRulePredicates()
{
SenderContains = new List <string>()
{
"testUser"
}
};
rule.Actions = new MessageRuleActions()
{
ForwardTo = new List <Recipient>()
{
new Recipient()
{
EmailAddress = new EmailAddress()
{
Address = "*****@*****.**"
}
}
},
StopProcessingRules = true
};
await rule.SaveAsync();
SearchFilter searchFilter = new SearchFilter.IsEqualTo(
MessageRuleObjectSchema.DisplayName,
ruleName);
FindItemResults <MessageRule> rules = await exchangeService.FindItems(
new MessageRuleView(),
searchFilter);
Assert.AreEqual(
1,
rules.TotalCount);
Assert.IsTrue(rules.Items[0].IsEnabled);
rule.IsEnabled = false;
await rule.UpdateAsync();
rules = await exchangeService.FindItems(
new MessageRuleView(),
searchFilter);
Assert.AreEqual(
1,
rules.TotalCount);
Assert.IsFalse(rules.Items[0].IsEnabled);
await rule.DeleteAsync();
}
public async Task CreateRule(string alias, string displayName, int sequence, bool isEnabled, string senderContains, string forwardToEmail)
{
MessageRule rule = BuildMailRule(displayName, sequence, isEnabled, senderContains, forwardToEmail);
User user = FindByAlias(alias).Result;
await _graphClient.Users[user.Id].MailFolders.Inbox.MessageRules.Request().AddAsync(rule);
}
