private int Save(MailSieveFilterData filterDataObj)
{
var filterData = GetValidFilter(filterDataObj);
var filterJsonStr = JsonConvert.SerializeObject(filterData, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new ShouldSerializeContractResolver()
});
var filter = new Filter
{
Id = filterData.Id,
User = User,
Tenant = Tenant,
Enabled = filterData.Enabled,
FilterData = filterJsonStr,
Position = filterData.Position
};
using (var daoFactory = new DaoFactory())
{
var dao = daoFactory.CreateFilterDao(Tenant, User);
var id = dao.Save(filter);
return(id);
}
}
public MailSieveFilterData CreateFilter(MailSieveFilterData filter)
{
var id = MailEngineFactory.FilterEngine.Create(filter);
filter.Id = id;
return(filter);
}
public int Create(MailSieveFilterData filterData)
{
if (filterData == null)
{
throw new ArgumentNullException("filterData");
}
if (filterData.Id != 0)
{
throw new ArgumentException("filterData.Id should be 0");
}
return(Save(filterData));
}
public bool Update(MailSieveFilterData filterData)
{
if (filterData == null)
{
throw new ArgumentNullException("filterData");
}
if (filterData.Id <= 0)
{
throw new InvalidDataException("filterData.Id should be more then 0");
}
return(Save(filterData) > 0);
}
public FilterSieveMessagesExp(List <int> ids, int tenant, string user, MailSieveFilterData filter, int page,
int pageSize)
{
Filter = filter;
Tenant = tenant;
User = user;
if (ids.Any())
{
Ids = ids.Skip(page * pageSize).Take(pageSize).ToList();
return;
}
StartIndex = page * pageSize;
Limit = pageSize;
}
public List <MailMessageData> CheckFilter(MailSieveFilterData filter, int?page, int?pageSize)
{
if (!page.HasValue)
{
page = 0;
}
if (!pageSize.HasValue)
{
pageSize = 10;
}
long total;
var messages = MailEngineFactory.MessageEngine.GetFilteredMessages(filter, page.Value, pageSize.Value, out total);
_context.SetTotalCount(total);
return(messages);
}
public static bool TryGetFullTextSearchIds(MailSieveFilterData filter, string user, out List <int> ids)
{
ids = new List <int>();
if (!FactoryIndexer <MailWrapper> .Support)
{
return(false);
}
var userId = new Guid(user);
Func <ConditionKeyType, Expression <Func <MailWrapper, object> > > getExp = (c) =>
{
switch (c)
{
case ConditionKeyType.From:
return(w => w.FromText);
case ConditionKeyType.To:
return(w => w.ToText);
case ConditionKeyType.Cc:
return(w => w.Cc);
case ConditionKeyType.Subject:
return(w => w.Subject);
default:
throw new ArgumentOutOfRangeException("c", c, null);
}
};
Func <MailSieveFilterConditionData, Selector <MailWrapper> > setSelector = (c) =>
{
var sel = new Selector <MailWrapper>().Match(
c.Key == ConditionKeyType.ToOrCc
? w => new object[] { w.ToText, w.Cc }
: getExp(c.Key),
c.Operation == ConditionOperationType.Matches || c.Operation == ConditionOperationType.NotMatches
? "\"" + c.Value + "\""
: c.Value);
if (c.Operation == ConditionOperationType.NotMatches ||
c.Operation == ConditionOperationType.NotContains)
{
return(new Selector <MailWrapper>().Not(s => sel));
}
return(sel);
};
var selector = new Selector <MailWrapper>();
foreach (var c in filter.Conditions)
{
if (filter.Options.MatchMultiConditions == MatchMultiConditionsType.MatchAll ||
filter.Options.MatchMultiConditions == MatchMultiConditionsType.None)
{
selector &= setSelector(c);
}
else
{
selector |= setSelector(c);
}
}
if (filter.Options.ApplyTo.Folders.Any())
{
selector.In(r => r.Folder, filter.Options.ApplyTo.Folders);
}
if (filter.Options.ApplyTo.Mailboxes.Any())
{
selector.In(r => r.MailboxId, filter.Options.ApplyTo.Mailboxes);
}
if (filter.Options.ApplyTo.WithAttachments != ApplyToAttachmentsType.WithAndWithoutAttachments)
{
selector.Where(r => r.HasAttachments,
filter.Options.ApplyTo.WithAttachments == ApplyToAttachmentsType.WithAttachments);
}
selector
.Where(r => r.UserId, userId)
.Sort(r => r.DateSent, true);
List <int> mailIds;
if (!FactoryIndexer <MailWrapper> .TrySelectIds(s => selector, out mailIds))
{
return(false);
}
ids = mailIds;
return(true);
}
public static MailSieveFilterData GetValidFilter(MailSieveFilterData filterData)
{
var validFilter = new MailSieveFilterData
{
Id = filterData.Id,
Enabled = filterData.Enabled
};
validFilter.Name = !string.IsNullOrEmpty(filterData.Name) && filterData.Name.Length > 64
? filterData.Name.Substring(0, 64)
: filterData.Name;
validFilter.Position = filterData.Position < 0 ? 0 : filterData.Position;
if (filterData.Options == null)
{
throw new ArgumentException("No options");
}
if (filterData.Options.ApplyTo == null)
{
throw new ArgumentException("No options apply to section");
}
if (filterData.Options.ApplyTo.Folders == null || !filterData.Options.ApplyTo.Folders.Any())
{
throw new ArgumentException("No folders in options");
}
var aceptedFolders = new[] { (int)FolderType.Inbox, (int)FolderType.Sent, (int)FolderType.Spam };
if (filterData.Options.ApplyTo.Folders.Any(f => !aceptedFolders.Contains(f)))
{
throw new ArgumentException("Some folder is not accepted in the options");
}
if (filterData.Options.ApplyTo.Mailboxes == null)
{
filterData.Options.ApplyTo.Mailboxes = new int[] {}
}
;
validFilter.Options = filterData.Options;
if (filterData.Conditions.Any(c => string.IsNullOrEmpty(c.Value)))
{
throw new ArgumentException("No condition value");
}
if (filterData.Conditions.Any(c => c.Value.Length > 200))
{
throw new ArgumentException("Too long condition value (limit is 200)");
}
validFilter.Conditions = filterData.Conditions;
if (!filterData.Actions.Any())
{
throw new ArgumentException("No actions");
}
validFilter.Actions = filterData.Actions.Distinct(new FilterActionEqualityComparer()).ToList();
if (filterData.Actions.Count > 1 && filterData.Actions.Any(a => a.Action == ActionType.DeleteForever))
{
validFilter.Actions = new List <MailSieveFilterActionData>
{
new MailSieveFilterActionData
{
Action = ActionType.DeleteForever
}
};
}
else
{
foreach (var actionData in validFilter.Actions)
{
switch (actionData.Action)
{
case ActionType.MoveTo:
if (string.IsNullOrEmpty(actionData.Data))
{
throw new ArgumentException("Empty folder of 'Move to' action");
}
JObject dataJson;
try
{
dataJson = JObject.Parse(actionData.Data);
}
catch (Exception)
{
throw new ArgumentException("Not json data of 'Move to' action");
}
if (!dataJson.HasValues)
{
throw new ArgumentException("Have no values in json data of 'Move to' action");
}
if (!dataJson.ContainsKey("type"))
{
throw new ArgumentException("Have no type value in json data of 'Move to' action");
}
FolderType folderType;
if (!Enum.TryParse(dataJson["type"].ToString(), true, out folderType) ||
!Enum.IsDefined(typeof(FolderType), folderType))
{
throw new ArgumentException("Not valid type value in json data of 'Move to' action");
}
if (folderType == FolderType.UserFolder)
{
if (!dataJson.ContainsKey("userFolderId"))
{
throw new ArgumentException(
"Have no userFolderId value in json data of 'Move to' action");
}
uint userFolderId;
if (!uint.TryParse(dataJson["userFolderId"].ToString(), out userFolderId))
{
throw new ArgumentException(
"Not valid userFolderId value in json data of 'Move to' action");
}
}
break;
case ActionType.MarkTag:
if (string.IsNullOrEmpty(actionData.Data))
{
throw new ArgumentException("Empty tag of 'Add tag' action");
}
int parsedId;
if (!int.TryParse(actionData.Data, out parsedId))
{
throw new ArgumentException("Not numeric tag id of 'Add tag' action");
}
break;
case ActionType.MarkAsImportant:
case ActionType.MarkAsRead:
case ActionType.DeleteForever:
if (!string.IsNullOrEmpty(actionData.Data))
{
actionData.Data = null;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
return(validFilter);
}
public MailSieveFilterData UpdateFilter(MailSieveFilterData filter)
{
MailEngineFactory.FilterEngine.Update(filter);
return(filter);
}
