public virtual void SynchronizeParticipants()
{
if (string.IsNullOrEmpty(Entity.Sender) && string.IsNullOrEmpty(Entity.Recepient))
{
return;
}
if (Entity.GetTypedColumnValue <Guid>("ActivityCategoryId") == ExchangeConsts.ActivityMeetingCategoryId)
{
var recepientsEmails = (List <string>)RecepientsEmails;
Dictionary <Guid, string> contactDictionary = ContactUtilities.GetContactsByEmails(UserConnection, recepientsEmails);
if (contactDictionary.Count > 0)
{
var participantRoles = ActivityUtils.GetParticipantsRoles(UserConnection);
foreach (var contactId in contactDictionary.Keys)
{
AddActivityParticipantToInsertedValues(
contactId,
new Dictionary <string, object> {
{ "RoleId", participantRoles["Participant"] }
},
false
);
}
var insertedValues = InsertedValues as Dictionary <Guid, object>;
if (insertedValues != null)
{
UpdateContactAndAccountByParticipant(insertedValues.Keys.ToList());
}
}
Entity.SetColumnValue("Sender", string.Empty);
Entity.SetColumnValue("Recepient", string.Empty);
}
}
/// <summary>
/// Returns unique hash for email instance. Send date would be converted to UTC using user timezone.
/// </summary>
/// <param name="sendDate">Email send date.</param>
/// <param name="title">Email subject.</param>
/// <param name="body">Email body.</param>
/// <param name="timeZoneInfo">User timezone.</param>
/// <param name="deleteWhiteSpaces">Flag, indicates if need to delete white spaces.</param>
/// <param name="dateTimeFormat">If <paramref name="deleteWhiteSpaces"/> is true,
/// then this parameter used for send date serialization.</param>
/// <param name="fixTitleWhitespaces">Fix repeating whitespaces in title flag.</param>
/// <returns>Unique hash for email instance.</returns>
protected string GetEmailHash(DateTime sendDate, string title, string body, TimeZoneInfo timeZoneInfo,
bool deleteWhiteSpaces = true, string dateTimeFormat = "yyyy-MM-dd HH:mm",
bool fixTitleWhitespaces = true)
{
return(ActivityUtils.GetEmailHash(sendDate, title, body, timeZoneInfo, deleteWhiteSpaces, dateTimeFormat,
fixTitleWhitespaces));
}
/// <summary>
/// Get recipients mailboxes.
/// </summary>
/// <returns>All recipients mailboxes.</returns>
private string[] GetRecipientMailboxes()
{
var parentActivityId = CaseEntity.GetTypedColumnValue <Guid>("ParentActivityId");
if (parentActivityId != default(Guid))
{
string allRecipients = GetRecipients(parentActivityId);
return(ActivityUtils.ParseEmailAddress(allRecipients).ToArray());
}
return(new string[0]);
}
public override IEnumerable <string> GetHashes(UserConnection userConnection, EmailHashDTO email)
{
List <string> hashes = new List <string>();
var subject = ActivityUtils.FixWhitespaces(email.Subject);
hashes.AddRange(GetHashesInternal(userConnection, new EmailHashDTO {
Subject = subject,
SendDate = email.SendDate,
Body = email.Body,
TimeZone = email.TimeZone
}));
return(hashes);
}
/// <inheritdoc />
protected override void SetActivityColumnValues(Entity entity)
{
base.SetActivityColumnValues(entity);
if (EmailBody.IsNotNullOrEmpty())
{
entity.SetColumnValue("MailHash",
ActivityUtils.GetEmailHash(
UserConnection,
entity.SafeGetColumnValue <DateTime>("SendDate"),
entity.SafeGetColumnValue <string>("Title"),
EmailBody,
UserConnection.CurrentUser.TimeZone));
}
}
/// <summary>
/// For each entry of Blacklist (Domain, Email adress, etc.) checks Sender property of given emailEntity activity
/// to match.
/// </summary>
/// <param name="emailEntity">Email activity.</param>
/// <returns>True if Sender property matches to any of blacklist entries and False otherwise.</returns>
public virtual bool CheckIsBlacklisted(Entity email)
{
var comparison = StringComparison.OrdinalIgnoreCase;
var sender = email.GetTypedColumnValue <string>(JunkFilterConsts.SenderColumnName);
sender = ActivityUtils.ExtractEmailAddress(sender);
string domain = Regex.Match(sender, JunkFilterConsts.DomainPattern).Value.TrimStart('@');
var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "Blacklist");
string typeCodeColumnName = esq.AddColumn("TypeOfField.Code").Name;
string name = esq.AddColumn("Name").Name;
EntityCollection filters = esq.GetEntityCollection(UserConnection);
foreach (var filter in filters)
{
var typeCode = filter.GetTypedColumnValue <string>(typeCodeColumnName);
var filteringValue = filter.GetTypedColumnValue <string>(name);
switch (typeCode)
{
case JunkFilterConsts.EmailTypeCode:
if (string.Equals(sender, filteringValue, comparison))
{
return(true);
}
break;
case JunkFilterConsts.DomainTypeCode:
if (string.Equals(domain, filteringValue, comparison))
{
return(true);
}
break;
case JunkFilterConsts.EntryTypeCode:
if (sender.IndexOf(filteringValue, comparison) >= 0)
{
return(true);
}
break;
default:
throw new Exception(new LocalizableString(UserConnection.ResourceStorage,
"RegistrationFromEmail", "UnsupportedTypeOfFieldErrorMsg"));
}
}
return(false);
}
/// <summary>
/// Initialazes initial parameters.
/// </summary>
/// <param name="email">Email entity.</param>
/// <param name="regenerate">Force regenerate participants flag.</param>
public virtual void InitializeParameters(Entity email, bool regenerate = false)
{
ParticipantRoles = ParticipantRoles ?? ActivityUtils.GetParticipantsRoles(UserConnection);
Email = email;
LoadEmailParticipants(email);
string sender = string.Empty;
var senderColumn = Email.Schema.Columns.FindByName("Sender");
if (senderColumn != null)
{
sender = Email.GetTypedColumnValue <string>(senderColumn.ColumnValueName);
}
SenderEmail = GetSenderEmail(sender);
foreach (EntityColumnValue column in GetChangedColumnValues(email, regenerate))
{
switch (column.Name)
{
case "Sender":
SenderEmail = column.Value != null?GetSenderEmail((string)column.Value) : string.Empty;
SaveSenderEmailDiff(column.Value, column.OldValue);
break;
case "Recepient":
RecepientsEmails = InitializeRecepients(column.Value, column.OldValue);
break;
case "CopyRecepient":
CopyRecepientsEmails = InitializeRecepients(column.Value, column.OldValue);
break;
case "BlindCopyRecepient":
BlindCopyRecepientsEmails = InitializeRecepients(column.Value, column.OldValue);
break;
case "ContactId":
SetContactsId(column.Value, column.OldValue);
break;
default:
break;
}
}
DeleteDuplicatesEmails();
}
public virtual void ClearCache()
{
ActivityUtils.ClearActivityCache(UserConnection);
}
/// <inheritdoc cref="IActivityUtils.GetSendDateTicks(UserConnection, Entity)"/>
public long GetSendDateTicks(UserConnection userConnection, Entity activity)
{
return(ActivityUtils.GetSendDateTicks(userConnection, activity));
}
/// <inheritdoc cref="IActivityUtils.GetSendDateFromTicks(UserConnection, long)"/>
public DateTime GetSendDateFromTicks(UserConnection userConnection, long ticks)
{
return(ActivityUtils.GetSendDateFromTicks(userConnection, ticks));
}
/// <inheritdoc cref="IActivityUtils.GetEmailHash(UserConnection, DateTime, string, string, TimeZoneInfo)"/>
public string GetEmailHash(UserConnection userConnection, DateTime sendDate, string title, string body,
TimeZoneInfo timeZoneInfo)
{
return(ActivityUtils.GetEmailHash(userConnection, sendDate, title, body, timeZoneInfo));
}
/// <inheritdoc cref="IActivityUtils.GetExistingEmaisIds(UserConnection, DateTime, string, string, TimeZoneInfo)"/>
public List <Guid> GetExistingEmaisIds(UserConnection userConnection, DateTime sendDate, string subject, string body,
TimeZoneInfo timeZoneInfo)
{
return(ActivityUtils.GetExistingEmaisIds(userConnection, sendDate, subject, body, timeZoneInfo));
}
/// <inheritdoc cref="IActivityUtils.GetAttachmentName(UserConnection, string)"/>
public string GetAttachmentName(UserConnection userConnection, string attachmentName)
{
return(ActivityUtils.GetAttachmentName(userConnection, attachmentName));
}
/// <inheritdoc cref="IActivityUtils.FixActivityTitle(string, UserConnection)"/>
public string FixActivityTitle(string value, UserConnection userConnection)
{
return(ActivityUtils.FixActivityTitle(value, userConnection));
}
