public static void Run()
{
// Create and initialize credentials
var credentials = new NetworkCredential("username", "12345");
// Create instance of ExchangeClient class by giving credentials
IEWSClient client = EWSClient.GetEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
// Get all tasks info collection from exchange
ExchangeMessageInfoCollection tasks = client.ListMessages(client.MailboxInfo.TasksUri);
// Parse all the tasks info in the list
foreach (ExchangeMessageInfo info in tasks)
{
// Fetch task from exchange using current task info
ExchangeTask task = client.FetchTask(info.UniqueUri);
// Update the task status to NotStarted
task.Status = ExchangeTaskStatus.NotStarted;
// Set the task due date
task.DueDate = new DateTime(2013, 2, 26);
// Set task priority
task.Priority = MailPriority.Low;
// Update task on exchange
client.UpdateTask(task);
}
Console.WriteLine(Environment.NewLine + "Task updated on Exchange Server successfully.");
}
private static void AppendRecurrenceTag(ExchangeTask task, StringBuilder xmlBuilder)
{
if (!task.IsRecurring)
{
return;
}
xmlBuilder.Append("<tasks:Recurrence>");
// Type
xmlBuilder.AppendFormat("<tasks:Type>{0}</tasks:Type>", GetRecurrencePatternInteger(task.RecurrenceType));
// Start
xmlBuilder.AppendFormat("<tasks:Start>{0}</tasks:Start>", task.Start.HasValue ? GetFullDateString(task.Start.Value) : GetFullDateString(task.Created));
//// Dead occur
//builder.AppendFormat("<tasks:DeadOccur>{0}</tasks:DeadOccur>", task.Completed.HasValue ? 1 : 0);
xmlBuilder.AppendFormat("<tasks:DeadOccur>{0}</tasks:DeadOccur>", 0);
// Regenerate
int regenerate = 0;
if (task.RecurrenceType == ExchangeRecurrencePattern.DailyRegeneration ||
task.RecurrenceType == ExchangeRecurrencePattern.WeeklyRegeneration ||
task.RecurrenceType == ExchangeRecurrencePattern.MonthlyRegeneration ||
task.RecurrenceType == ExchangeRecurrencePattern.YearlyRegeneration)
{
regenerate = 1;
}
xmlBuilder.AppendFormat("<tasks:Regenerate>{0}</tasks:Regenerate>", regenerate);
// Interval
xmlBuilder.AppendFormat("<tasks:Interval>{0}</tasks:Interval>", task.Interval == 0 ? 1 : task.Interval);
// DayOfWeek
if (task.RecurrenceType == ExchangeRecurrencePattern.Weekly || task.RecurrenceType == ExchangeRecurrencePattern.MonthlyRelative)
{
xmlBuilder.AppendFormat("<tasks:DayOfWeek>{0}</tasks:DayOfWeek>", (int)task.DaysOfWeek);
}
// DayOfMonth
if (task.RecurrenceType == ExchangeRecurrencePattern.Monthly || task.RecurrenceType == ExchangeRecurrencePattern.Yearly)
{
xmlBuilder.AppendFormat("<tasks:DayOfMonth>{0}</tasks:DayOfMonth>", task.DayOfMonth == 0 ? 1 : task.DayOfMonth);
}
// WeekOfMonth
if (task.RecurrenceType == ExchangeRecurrencePattern.MonthlyRelative)
{
xmlBuilder.AppendFormat("<tasks:WeekOfMonth>{0}</tasks:WeekOfMonth>", (int)task.DayOfWeekIndex + 1);
}
// MonthOfYear
if (task.RecurrenceType == ExchangeRecurrencePattern.Yearly)
{
xmlBuilder.AppendFormat("<tasks:MonthOfYear>{0}</tasks:MonthOfYear>", task.Month == 0 ? 1 : task.Month);
}
xmlBuilder.Append("</tasks:Recurrence>");
}
public static ITask ToTask(this ExchangeTask exchangeTask, IWorkbook workbook)
{
var task = workbook.CreateTask();
task.Added = DateTime.Now;
task.UpdateFromExchange(exchangeTask);
return(task);
}
public static void Run()
{
// ExStart:FilterTasksFromServer
// Set mailboxURI, Username, password, domain information
string mailboxUri = "https://ex2010/ews/exchange.asmx";
string username = "******";
string password = "******";
string domain = "ex2010.local";
NetworkCredential credentials = new NetworkCredential(username, password, domain);
IEWSClient client = EWSClient.GetEWSClient(mailboxUri, credentials);
ExchangeQueryBuilder queryBuilder = null;
MailQuery query = null;
ExchangeTask fetchedTask = null;
ExchangeMessageInfoCollection messageInfoCol = null;
client.TimezoneId = "Central Europe Standard Time";
Array values = Enum.GetValues(typeof(ExchangeTaskStatus));
//Now retrieve the tasks with specific statuses
foreach (ExchangeTaskStatus status in values)
{
queryBuilder = new ExchangeQueryBuilder();
queryBuilder.TaskStatus.Equals(status);
query = queryBuilder.GetQuery();
messageInfoCol = client.ListMessages(client.MailboxInfo.TasksUri, query);
fetchedTask = client.FetchTask(messageInfoCol[0].UniqueUri);
}
//retrieve all other than specified
foreach (ExchangeTaskStatus status in values)
{
queryBuilder = new ExchangeQueryBuilder();
queryBuilder.TaskStatus.NotEquals(status);
query = queryBuilder.GetQuery();
messageInfoCol = client.ListMessages(client.MailboxInfo.TasksUri, query);
}
//specifying multiple criterion
ExchangeTaskStatus[] selectedStatuses = new ExchangeTaskStatus[]
{
ExchangeTaskStatus.Completed,
ExchangeTaskStatus.InProgress
};
queryBuilder = new ExchangeQueryBuilder();
queryBuilder.TaskStatus.In(selectedStatuses);
query = queryBuilder.GetQuery();
messageInfoCol = client.ListMessages(client.MailboxInfo.TasksUri, query);
queryBuilder = new ExchangeQueryBuilder();
queryBuilder.TaskStatus.NotIn(selectedStatuses);
query = queryBuilder.GetQuery();
messageInfoCol = client.ListMessages(client.MailboxInfo.TasksUri, query);
//ExEnd:FilterTasksFromServer
}
public static void Run()
{
// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Exchange();
string dstEmail = dataDir + "Message.msg";
ExchangeTask task = new ExchangeTask();
task.Subject = "TASK-ID - " + Guid.NewGuid();
task.Status = ExchangeTaskStatus.InProgress;
task.StartDate = DateTime.Now;
task.DueDate = task.StartDate.AddDays(3);
task.Save(dstEmail);
Console.WriteLine(Environment.NewLine + "Task saved on disk successfully at " + dstEmail);
}
public static void Run()
{
// ExStart:ProcessExchangeTasksUsingIEWSClient
// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.GetEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
// Create Exchange task object
ExchangeTask task = new ExchangeTask();
// Set task subject and status to In progress
task.Subject = "New-Test";
task.Status = ExchangeTaskStatus.InProgress;
client.CreateTask(client.MailboxInfo.TasksUri, task);
// ExEnd:ProcessExchangeTasksUsingIEWSClient
}
public static void Run()
{
// ExStart:ProcessExchangeTasksUsingIEWSClient
// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.GetEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
// Create Exchange task object
ExchangeTask task = new ExchangeTask();
// Set task subject and status to In progress
task.Subject = "New-Test";
task.Status = ExchangeTaskStatus.InProgress;
client.CreateTask(client.MailboxInfo.TasksUri, task);
// ExEnd:ProcessExchangeTasksUsingIEWSClient
}
public static void Run()
{
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_Exchange();
string dstEmail = dataDir + "Message.msg";
ExchangeTask task = new ExchangeTask();
task.Subject = "TASK-ID - " + Guid.NewGuid();
task.Status = ExchangeTaskStatus.InProgress;
task.StartDate = DateTime.Now;
task.DueDate = task.StartDate.AddDays(3);
task.Save(dstEmail);
Console.WriteLine(Environment.NewLine + "Task saved on disk successfully at " + dstEmail);
}
public static ExchangeTask BuildExchangeTask(this EwsTask ewsTask)
{
var id = string.Format("{0}{1}{2}", ewsTask.Id, ChangeKeySeparator, ewsTask.ChangeKey);
if (ewsTask.Type == EwsItemType.Item)
{
id = ItemPrefix + id;
}
var exchangeTask = new ExchangeTask
{
Id = id,
Subject = ewsTask.Subject,
Start = ewsTask.StartDate,
Due = ewsTask.DueDate,
Completed = ewsTask.CompleteDate,
Importance = (ExchangeTaskImportance)(int)ewsTask.Importance,
};
if (ewsTask.ReminderIsSet && ewsTask.ReminderDate.HasValue && ewsTask.ReminderDate.Value != DateTime.MinValue)
{
exchangeTask.Alarm = ewsTask.ReminderDate;
}
if (!string.IsNullOrWhiteSpace(ewsTask.Body))
{
exchangeTask.Note = ewsTask.Body;
}
if (ewsTask.Categories != null && ewsTask.Categories.Length > 0)
{
exchangeTask.Category = ewsTask.Categories[0];
}
if (ewsTask.Recurrence != null && ewsTask.Recurrence.RecurrenceType != ExchangeRecurrencePattern.None)
{
exchangeTask.IsRecurring = true;
exchangeTask.DayOfMonth = ewsTask.Recurrence.DayOfMonth;
exchangeTask.DayOfWeekIndex = ewsTask.Recurrence.DayOfWeekIndex;
exchangeTask.DaysOfWeek = ewsTask.Recurrence.DaysOfWeek;
exchangeTask.Interval = ewsTask.Recurrence.Interval;
exchangeTask.Month = ewsTask.Recurrence.Month;
exchangeTask.RecurrenceType = ewsTask.Recurrence.RecurrenceType;
}
return(exchangeTask);
}
public static void Run()
{
// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.GetEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
// Create Exchange task object
ExchangeTask task = new ExchangeTask();
// Set task subject
task.Subject = "New-Test";
// Set task status to In progress
task.Status = ExchangeTaskStatus.InProgress;
// Create task on exchange
client.CreateTask(client.MailboxInfo.TasksUri, task);
Console.WriteLine(Environment.NewLine + "Task created on Exchange Server successfully.");
}
private ExchangeChangeSet GetChangeSet(ExchangeTask added = null, ExchangeTask modified = null, IEnumerable <string> deleted = null)
{
var changeset = new ExchangeChangeSet();
if (added != null)
{
changeset.AddedTasks.Add(added);
}
if (modified != null)
{
changeset.ModifiedTasks.Add(modified);
}
if (deleted != null)
{
deleted.ForEach(d => changeset.DeletedTasks.Add(new ServerDeletedAsset(d)));
}
return(changeset);
}
private IFolder GetFolderForExchangeTask(ExchangeTask exchangeTask)
{
IFolder folder = null;
if (!string.IsNullOrEmpty(exchangeTask.Category))
{
// check a folder match the name
folder = this.Workbook.Folders.FirstOrDefault(f => f.Name.Equals(exchangeTask.Category, StringComparison.OrdinalIgnoreCase));
if (folder == null)
{
// no folder found and the task in exchange has a category
// create a folder with the name of the category
folder = this.CreateFolder(exchangeTask.Category);
}
}
else
{
// the task has no folder, use the default one
folder = this.GetDefaultFolder();
}
return(folder);
}
public static void Run()
{
// ExStart:DeleteTaskOnExchange
// Create instance of ExchangeClient class by giving credentials
IEWSClient client = EWSClient.GetEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
// Get all tasks info collection from exchange
ExchangeMessageInfoCollection tasks = client.ListMessages(client.MailboxInfo.TasksUri);
// Parse all the tasks info in the list
foreach (ExchangeMessageInfo info in tasks)
{
// Fetch task from exchange using current task info
ExchangeTask task = client.FetchTask(info.UniqueUri);
// Check if the current task fulfills the search criteria
if (task.Subject.Equals("test"))
{
//Delete task from exchange
client.DeleteItem(task.UniqueUri, DeletionOptions.DeletePermanently);
}
}
// ExEnd:DeleteTaskOnExchange
}
private static void CreateTaskXml(ExchangeTask task, StringBuilder builder, bool isAdd)
{
// Server Id (in case of update)
if (isAdd)
{
builder.AppendFormat("<ClientId>{0}</ClientId>", task.LocalId);
}
else
{
builder.AppendFormat("<ServerId>{0}</ServerId>", task.Id);
}
builder.Append("<ApplicationData>");
// Subject
builder.AppendFormat("<tasks:Subject>{0}</tasks:Subject>", task.Subject.ToEscapedXml());
// Notes
builder.Append("<airsyncbase:Body>");
builder.Append("<airsyncbase:Type>1</airsyncbase:Type>");
builder.AppendFormat("<airsyncbase:Data>{0}</airsyncbase:Data>", !string.IsNullOrEmpty(task.Note) ? task.Note.ToEscapedXml() : " ");
builder.Append("</airsyncbase:Body>");
// Category
if (!string.IsNullOrEmpty(task.Category))
{
builder.Append("<tasks:Categories>");
builder.AppendFormat("<tasks:Category>{0}</tasks:Category>", task.Category.ToEscapedXml());
builder.Append("</tasks:Categories>");
}
// Complete
builder.AppendFormat("<tasks:Complete>{0}</tasks:Complete>", task.Completed.HasValue ? "1" : "0");
// Completed
if (task.Completed.HasValue)
{
builder.AppendFormat("<tasks:DateCompleted>{0}</tasks:DateCompleted>", GetFullDateString(task.Completed.Value.ToUniversalTime()));
}
// Due Date
if (task.Due.HasValue)
{
builder.AppendFormat("<tasks:DueDate>{0}</tasks:DueDate>", GetFullDateString(task.Due.Value));
builder.AppendFormat("<tasks:UtcDueDate>{0}</tasks:UtcDueDate>", GetFullDateString(task.Due.Value.ToUniversalTime()));
}
// Priority
builder.AppendFormat("<tasks:Importance>{0}</tasks:Importance>", (int)task.Importance);
if (task.Start.HasValue)
{
// Start Date
builder.AppendFormat("<tasks:StartDate>{0}</tasks:StartDate>", GetFullDateString(task.Start.Value));
builder.AppendFormat("<tasks:UtcStartDate>{0}</tasks:UtcStartDate>", GetFullDateString(task.Start.Value.ToUniversalTime()));
}
// Recurrence
AppendRecurrenceTag(task, builder);
// Sensitivity
builder.Append("<tasks:Sensitivity>0</tasks:Sensitivity>");
// Reminder
if (task.Alarm.HasValue)
{
builder.Append("<tasks:ReminderSet>1</tasks:ReminderSet>");
builder.AppendFormat("<tasks:ReminderTime>{0}</tasks:ReminderTime>", GetFullDateString(task.Alarm.Value.ToUniversalTime()));
}
builder.Append("</ApplicationData>");
}
public static ExchangeTask GetExchangeTask(XElement task)
{
try
{
ExchangeTask result = new ExchangeTask();
XElement data = task.Element("ApplicationData");
// Manage common fields
result.Id = task.Element("ServerId").Value;
if (data.Element("Subject") != null)
{
result.Subject = data.Element("Subject").Value;
}
else
{
result.Subject = "-";
}
result.Note = data.Elements("Body").Any() && data.Element("Body").Elements("Data").Any()
? data.Element("Body").Element("Data").Value : null;
if (!string.IsNullOrEmpty(result.Note) && result.Note.StartsWith(ReportedNoteCrumbles))
{
result.Note = result.Note.Substring(ReportedNoteCrumbles.Length);
result.Note = result.Note.TrimEnd('\n');
}
if (string.IsNullOrWhiteSpace(result.Note))
{
result.Note = null;
}
result.Due = data.Element("DueDate") != null?GetDate(data.Element("DueDate").Value) : null;
result.Start = data.Element("StartDate") != null?GetDate(data.Element("StartDate").Value) : null;
var categories = data.Element("Categories");
if (categories != null)
{
var category = categories.Elements("Category");
if (category != null && category.Any())
{
result.Category = category.First().Value;
}
}
if (data.Element("Complete") != null && data.Element("Complete").Value == "1")
{
var applicationData = task.Element("ApplicationData");
if (applicationData != null)
{
var dateCompleted = applicationData.Element("DateCompleted");
if (dateCompleted != null && dateCompleted.Value != null)
{
result.Completed = GetDate(dateCompleted.Value);
}
}
// ActiveSync specification specify that is "Complete" is set to 1, a DateCompleted must be included:
// "The DateCompleted element MUST be included in the response if the Complete element (section 2.2.2.7) value is 1."
// but for some reason, that's not the case when syncing with AkrutoSync and Memotoo, and in that case we fallback
// to "now" for the completion date
if (result.Completed == null)
{
result.Completed = DateTime.Now;
}
}
result.Importance = data.Element("Importance") != null ? (ExchangeTaskImportance)int.Parse(data.Element("Importance").Value) : ExchangeTaskImportance.Normal;
result.IsRecurring = data.Element("Recurrence") != null;
XElement recurrence = data.Element("Recurrence");
if (result.IsRecurring)
{
// Get the DeadOccur property to know if it is a "real" recurring task or only an instance
if (recurrence.Element("DeadOccur") != null)
{
int deadOccur = int.Parse(recurrence.Element("DeadOccur").Value);
if (deadOccur > 0)
{
result.IsRecurring = false;
}
}
else
{
// No "DeadOccur" element, we assume (from the documentation) that value is equal to 0
result.IsRecurring = false;
}
}
XElement reminderSet = data.Element("ReminderSet");
if (reminderSet != null && reminderSet.Value == "1")
{
XElement reminderTime = data.Element("ReminderTime");
if (reminderTime != null && !string.IsNullOrWhiteSpace(reminderTime.Value))
{
result.Alarm = GetDate(reminderTime.Value);
if (result.Alarm.HasValue)
{
result.Alarm = result.Alarm.Value.ToLocalTime();
}
}
}
if (result.IsRecurring)
{
int regenerate = 0;
if (recurrence.Element("Regenerate") != null && !string.IsNullOrEmpty(recurrence.Element("Regenerate").Value) && int.TryParse(recurrence.Element("Regenerate").Value, out regenerate))
{
result.UseFixedDate = regenerate != 1;
}
result.RecurrenceType = result.IsRecurring ? GetRecurrencePattern(int.Parse(recurrence.Element("Type").Value), result.UseFixedDate) : ExchangeRecurrencePattern.None;
// Manage recurring fields
result.Interval = int.Parse(recurrence.Element("Interval").Value);
// DayOfWeek element
result.DaysOfWeek = ExchangeDayOfWeek.None;
if (result.RecurrenceType == ExchangeRecurrencePattern.Weekly || result.RecurrenceType == ExchangeRecurrencePattern.MonthlyRelative)
{
int days = 0;
if (recurrence.Element("DayOfWeek") != null)
{
days = int.Parse(recurrence.Element("DayOfWeek").Value);
}
result.DaysOfWeek = (ExchangeDayOfWeek)days;
if (HasMultipleDays(result.DaysOfWeek) && result.RecurrenceType == ExchangeRecurrencePattern.Weekly)
{
result.Interval = 0; // Set interval to 0 to avoid the Weekly standard pattern
}
}
// DayOfMonth element
result.DayOfMonth = 0;
if (result.RecurrenceType == ExchangeRecurrencePattern.Monthly || result.RecurrenceType == ExchangeRecurrencePattern.Yearly)
{
result.DayOfMonth = int.Parse(recurrence.Element("DayOfMonth").Value);
}
// WeekOfMonth element
if (result.RecurrenceType == ExchangeRecurrencePattern.MonthlyRelative)
{
// TODO : manage 'Yearly in the nth month' pattern
result.DayOfWeekIndex = GetDayOfTheWeekIndex(int.Parse(recurrence.Element("WeekOfMonth").Value));
}
// MonthOfYear element
if (result.RecurrenceType == ExchangeRecurrencePattern.Yearly)
{
// TODO : manage 'Yearly in the nth month' pattern
result.Month = int.Parse(recurrence.Element("MonthOfYear").Value);
}
LogService.Log("SyncCommandResult", $"Task {result.Subject} read completed");
}
return(result);
}
catch (Exception ex)
{
using (var sw = new StringWriter())
{
using (var xw = XmlWriter.Create(sw))
{
task.WriteTo(xw);
}
string content = sw.ToString().Replace("\r\n", string.Empty);
string message = $"Error when parsing task XML {ex}: {content}";
LogService.Log("SyncCommandResult", message);
TryTrackEvent("Parsing", message);
throw new CommandException("unable to read task content");
}
}
}
protected virtual bool HaveSameId(ITask task, ExchangeTask exchangeTask)
{
return(task.SyncId == exchangeTask.Id);
}
public static EwsTask BuildEwsTask(this ExchangeTask exchangeTask)
{
var ewsTask = new EwsTask
{
Subject = exchangeTask.Subject,
Categories = new[] { exchangeTask.Category },
StartDate = exchangeTask.Start,
CompleteDate = exchangeTask.Completed,
Importance = (EwsImportance)(int)exchangeTask.Importance
};
if (exchangeTask.Due.HasValue)
{
ewsTask.DueDate = exchangeTask.Due.Value.Date;
}
if (exchangeTask.Alarm.HasValue)
{
ewsTask.ReminderDate = exchangeTask.Alarm;
ewsTask.ReminderIsSet = true;
}
if (!string.IsNullOrWhiteSpace(exchangeTask.Note))
{
ewsTask.Body = exchangeTask.Note;
ewsTask.BodyType = exchangeTask.Note.HasHtml() ? EwsBodyType.HTML : EwsBodyType.Text;
}
if (!exchangeTask.Properties.HasValue)
{
throw new NotSupportedException("Task has no properties set");
}
if (exchangeTask.IsRecurring && exchangeTask.Due.HasValue)
{
var recurrence = new EwsRecurrence
{
RecurrenceType = exchangeTask.RecurrenceType,
Interval = exchangeTask.Interval,
DayOfMonth = exchangeTask.DayOfMonth,
DayOfWeekIndex = exchangeTask.DayOfWeekIndex,
DaysOfWeek = exchangeTask.DaysOfWeek,
Month = exchangeTask.Month,
};
if (!exchangeTask.Start.HasValue)
{
recurrence.StartDate = exchangeTask.Due.Value;
}
else
{
recurrence.StartDate = exchangeTask.Start.Value;
}
ewsTask.Recurrence = recurrence;
}
if (exchangeTask.Properties.Value.HasFlag(ExchangeTaskProperties.Title))
{
ewsTask.Changes |= EwsFields.Subject;
}
if (exchangeTask.Properties.Value.HasFlag(ExchangeTaskProperties.Folder))
{
ewsTask.Changes |= EwsFields.Categories;
}
if (exchangeTask.Properties.Value.HasFlag(ExchangeTaskProperties.Due))
{
ewsTask.Changes |= EwsFields.DueDate;
}
if (exchangeTask.Properties.Value.HasFlag(ExchangeTaskProperties.Start))
{
ewsTask.Changes |= EwsFields.StartDate;
}
if (exchangeTask.Properties.Value.HasFlag(ExchangeTaskProperties.Completed))
{
ewsTask.Changes |= EwsFields.CompleteDate;
}
if (exchangeTask.Properties.Value.HasFlag(ExchangeTaskProperties.Priority))
{
ewsTask.Changes |= EwsFields.Importance;
}
if (exchangeTask.Properties.Value.HasFlag(ExchangeTaskProperties.RepeatFrom))
{
ewsTask.Changes |= EwsFields.Recurrence;
}
if (exchangeTask.Properties.Value.HasFlag(ExchangeTaskProperties.Alarm))
{
ewsTask.Changes |= EwsFields.Reminder;
}
if (exchangeTask.Properties.Value.HasFlag(ExchangeTaskProperties.Note))
{
ewsTask.Changes |= EwsFields.Body;
}
if (!string.IsNullOrWhiteSpace(exchangeTask.Id))
{
string id = exchangeTask.Id;
if (exchangeTask.Id.StartsWith(ItemPrefix))
{
id = id.Replace(ItemPrefix, string.Empty);
ewsTask.Type = EwsItemType.Item;
}
var identifier = GetEwsItemIdentifier(id);
ewsTask.Id = identifier.Id;
ewsTask.ChangeKey = identifier.ChangeKey;
}
return(ewsTask);
}
protected override bool HaveSameId(ITask task, ExchangeTask exchangeTask)
{
return(task.SyncId != null && exchangeTask.Id != null && task.SyncId.GetEwsItemIdentifier().Id == exchangeTask.Id.GetEwsItemIdentifier().Id);
}
public static ExchangeTask ToExchangeTask(this ITask task, bool setCategory, TaskProperties properties)
{
var exchangeTask = new ExchangeTask
{
Subject = task.Title,
Importance = task.Priority.GetImportance(),
Completed = task.Completed,
Due = task.Due,
Start = task.Start,
LocalId = task.Id,
Id = task.SyncId,
Note = task.Note,
Created = task.Added,
Alarm = task.Alarm,
Properties = (ExchangeTaskProperties?)properties
};
// flag must be set to false when the folder that owns the task is the default
// folder we create for task without category in Exchange
if (setCategory)
{
exchangeTask.Category = task.Folder.Name;
}
if (task.Progress.HasValue)
{
exchangeTask.ProgressPercent = task.Progress.Value;
}
if (task.IsPeriodic && task.Due.HasValue)
{
exchangeTask.IsRecurring = true;
exchangeTask.UseFixedDate = task.UseFixedDate;
if (task.CustomFrequency is DailyFrequency)
{
var frequency = (DailyFrequency)task.CustomFrequency;
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.Daily;
exchangeTask.Interval = 1;
}
else if (task.CustomFrequency is DaysOfWeekFrequency)
{
var frequency = (DaysOfWeekFrequency)task.CustomFrequency;
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.Weekly;
exchangeTask.Interval = 1;
if (frequency.IsMonday)
{
exchangeTask.DaysOfWeek |= ExchangeDayOfWeek.Monday;
}
if (frequency.IsTuesday)
{
exchangeTask.DaysOfWeek |= ExchangeDayOfWeek.Tuesday;
}
if (frequency.IsWednesday)
{
exchangeTask.DaysOfWeek |= ExchangeDayOfWeek.Wednesday;
}
if (frequency.IsThursday)
{
exchangeTask.DaysOfWeek |= ExchangeDayOfWeek.Thursday;
}
if (frequency.IsFriday)
{
exchangeTask.DaysOfWeek |= ExchangeDayOfWeek.Friday;
}
if (frequency.IsSaturday)
{
exchangeTask.DaysOfWeek |= ExchangeDayOfWeek.Saturday;
}
if (frequency.IsSunday)
{
exchangeTask.DaysOfWeek |= ExchangeDayOfWeek.Sunday;
}
}
else if (task.CustomFrequency is EveryXPeriodFrequency)
{
var frequency = (EveryXPeriodFrequency)task.CustomFrequency;
exchangeTask.Interval = frequency.Rate;
switch (frequency.Scale)
{
case CustomFrequencyScale.Day:
if (exchangeTask.UseFixedDate)
{
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.Daily;
}
else
{
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.DailyRegeneration;
}
break;
case CustomFrequencyScale.Week:
if (exchangeTask.UseFixedDate)
{
exchangeTask.DaysOfWeek = task.Due.Value.DayOfWeek.ToExchangeDayOfWeek();
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.Weekly;
}
else
{
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.WeeklyRegeneration;
}
break;
case CustomFrequencyScale.Month:
if (exchangeTask.UseFixedDate)
{
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.Monthly;
exchangeTask.DayOfMonth = task.Due.Value.Day;
}
else
{
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.MonthlyRegeneration;
}
break;
case CustomFrequencyScale.Year:
if (exchangeTask.UseFixedDate)
{
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.Yearly;
exchangeTask.DayOfMonth = task.Due.Value.Day;
exchangeTask.Month = task.Due.Value.Month;
}
else
{
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.YearlyRegeneration;
}
break;
}
}
else if (task.CustomFrequency is WeeklyFrequency)
{
var frequency = (WeeklyFrequency)task.CustomFrequency;
exchangeTask.IsRecurring = true;
if (!task.Start.HasValue)
{
exchangeTask.DaysOfWeek = task.Due.Value.DayOfWeek.ToExchangeDayOfWeek();
}
else
{
exchangeTask.DaysOfWeek = task.Start.Value.DayOfWeek.ToExchangeDayOfWeek();
}
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.Weekly;
exchangeTask.Interval = 1;
}
else if (task.CustomFrequency is MonthlyFrequency && task.Due.HasValue)
{
var frequency = (MonthlyFrequency)task.CustomFrequency;
exchangeTask.IsRecurring = true;
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.Monthly;
exchangeTask.Interval = 1;
exchangeTask.DayOfMonth = task.Due.Value.Date.Day;
}
else if (task.CustomFrequency is OnXDayFrequency)
{
var frequency = (OnXDayFrequency)task.CustomFrequency;
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.MonthlyRelative;
exchangeTask.Interval = 1;
exchangeTask.DaysOfWeek = frequency.DayOfWeek.ToExchangeDayOfWeek();
exchangeTask.DayOfWeekIndex = frequency.RankingPosition.ToExchangeDayIndex();
}
else if (task.CustomFrequency is YearlyFrequency && task.Due.HasValue)
{
var frequency = (YearlyFrequency)task.CustomFrequency;
exchangeTask.IsRecurring = true;
exchangeTask.RecurrenceType = ExchangeRecurrencePattern.Yearly;
exchangeTask.Interval = 1;
exchangeTask.DayOfMonth = task.Due.Value.Date.Day;
exchangeTask.Month = task.Due.Value.Date.Month;
}
}
return(exchangeTask);
}
public static void UpdateFromExchange(this ITask task, ExchangeTask exchangeTask)
{
task.Title = exchangeTask.Subject;
task.Priority = exchangeTask.Importance.GetPriority();
task.Completed = exchangeTask.Completed;
task.Due = exchangeTask.Due;
task.Start = exchangeTask.Start;
task.SyncId = exchangeTask.Id;
task.Note = exchangeTask.Note;
task.Alarm = exchangeTask.Alarm;
// set the progress in the task if the value is exchange is more than 0 (ie, the user has set a value - 0 being the default value for all tasks)
// or if the task has a value which is different from the value in exchange
if (exchangeTask.ProgressPercent > 0 || (task.Progress.HasValue && task.Progress.Value != exchangeTask.ProgressPercent))
{
// Progress is between 0.0 and 1.0
task.Progress = exchangeTask.ProgressPercent / 100;
}
task.Modified = DateTime.Now;
// Remove recurring if task is completed
if (!exchangeTask.IsRecurring || exchangeTask.Completed.HasValue)
{
task.FrequencyType = FrequencyType.Once;
}
else
{
task.UseFixedDate = true;
switch (exchangeTask.RecurrenceType)
{
case ExchangeRecurrencePattern.None:
break;
case ExchangeRecurrencePattern.Daily:
case ExchangeRecurrencePattern.DailyRegeneration:
if (exchangeTask.Interval == 1)
{
task.CustomFrequency = FrequencyFactory.GetCustomFrequency(FrequencyType.Daily);
}
else
{
var frequency = FrequencyFactory.GetCustomFrequency <EveryXPeriodFrequency>(FrequencyType.EveryXPeriod);
frequency.Scale = CustomFrequencyScale.Day;
frequency.Rate = exchangeTask.Interval;
task.CustomFrequency = frequency;
}
task.UseFixedDate = exchangeTask.RecurrenceType == ExchangeRecurrencePattern.Daily;
break;
case ExchangeRecurrencePattern.Weekly:
case ExchangeRecurrencePattern.WeeklyRegeneration:
if (exchangeTask.Interval < 2)
{
int daysCount = 0;
var frequency = FrequencyFactory.GetCustomFrequency <DaysOfWeekFrequency>(FrequencyType.DaysOfWeek);
if ((exchangeTask.DaysOfWeek & ExchangeDayOfWeek.Monday) == ExchangeDayOfWeek.Monday)
{
daysCount++;
frequency.IsMonday = true;
}
if ((exchangeTask.DaysOfWeek & ExchangeDayOfWeek.Tuesday) == ExchangeDayOfWeek.Tuesday)
{
daysCount++;
frequency.IsTuesday = true;
}
if ((exchangeTask.DaysOfWeek & ExchangeDayOfWeek.Wednesday) == ExchangeDayOfWeek.Wednesday)
{
daysCount++;
frequency.IsWednesday = true;
}
if ((exchangeTask.DaysOfWeek & ExchangeDayOfWeek.Thursday) == ExchangeDayOfWeek.Thursday)
{
daysCount++;
frequency.IsThursday = true;
}
if ((exchangeTask.DaysOfWeek & ExchangeDayOfWeek.Friday) == ExchangeDayOfWeek.Friday)
{
daysCount++;
frequency.IsFriday = true;
}
if ((exchangeTask.DaysOfWeek & ExchangeDayOfWeek.Saturday) == ExchangeDayOfWeek.Saturday)
{
daysCount++;
frequency.IsSaturday = true;
}
if ((exchangeTask.DaysOfWeek & ExchangeDayOfWeek.Sunday) == ExchangeDayOfWeek.Sunday)
{
daysCount++;
frequency.IsSunday = true;
}
// if the weekly frequency repeat on a single day that match the due date or the start date
// use the WeeklyFrequency instead of DaysOfWeek
bool matchDaysOfWeek = (!exchangeTask.Start.HasValue && exchangeTask.Due.HasValue && exchangeTask.DaysOfWeek.ToDayOfWeek() == exchangeTask.Due.Value.DayOfWeek) ||
(exchangeTask.Start.HasValue && exchangeTask.DaysOfWeek.ToDayOfWeek() == exchangeTask.Start.Value.DayOfWeek);
if (daysCount == 0 || (daysCount == 1 && matchDaysOfWeek))
{
task.CustomFrequency = FrequencyFactory.GetCustomFrequency(FrequencyType.Weekly);
}
else if (daysCount > 0)
{
task.CustomFrequency = frequency;
}
else
{
TrackingManagerHelper.Trace("Exchange update task weekly frequency without days");
}
}
else
{
var frequency = FrequencyFactory.GetCustomFrequency <EveryXPeriodFrequency>(FrequencyType.EveryXPeriod);
frequency.Scale = CustomFrequencyScale.Week;
frequency.Rate = exchangeTask.Interval;
task.CustomFrequency = frequency;
}
task.UseFixedDate = exchangeTask.RecurrenceType == ExchangeRecurrencePattern.Weekly;
break;
case ExchangeRecurrencePattern.Monthly:
case ExchangeRecurrencePattern.MonthlyRegeneration:
if (exchangeTask.Interval < 2)
{
task.CustomFrequency = FrequencyFactory.GetCustomFrequency(FrequencyType.Monthly);
}
else
{
var frequency = FrequencyFactory.GetCustomFrequency <EveryXPeriodFrequency>(FrequencyType.EveryXPeriod);
frequency.Scale = CustomFrequencyScale.Month;
frequency.Rate = exchangeTask.Interval;
task.CustomFrequency = frequency;
}
task.UseFixedDate = exchangeTask.RecurrenceType == ExchangeRecurrencePattern.Monthly;
break;
case ExchangeRecurrencePattern.MonthlyRelative:
{
if (exchangeTask.Interval == 1)
{
var frequency = FrequencyFactory.GetCustomFrequency <OnXDayFrequency>(FrequencyType.OnXDayOfEachMonth);
frequency.RankingPosition = exchangeTask.DayOfWeekIndex.ToRankingPosition();
frequency.DayOfWeek = exchangeTask.DaysOfWeek.ToDayOfWeek();
task.CustomFrequency = frequency;
}
else if (exchangeTask.Interval > 1)
{
if (exchangeTask.Due.HasValue && exchangeTask.Due.Value.DayOfWeek == exchangeTask.DaysOfWeek.ToDayOfWeek())
{
// repeat every N month, day of the week match due date => use EveryXPeriod
var frequency = FrequencyFactory.GetCustomFrequency <EveryXPeriodFrequency>(FrequencyType.EveryXPeriod);
frequency.Rate = exchangeTask.Interval;
frequency.Scale = CustomFrequencyScale.Month;
task.CustomFrequency = frequency;
}
}
}
break;
case ExchangeRecurrencePattern.Yearly:
case ExchangeRecurrencePattern.YearlyRegeneration:
if (exchangeTask.Interval < 2)
{
task.CustomFrequency = FrequencyFactory.GetCustomFrequency(FrequencyType.Yearly);
}
else
{
var frequency = FrequencyFactory.GetCustomFrequency <EveryXPeriodFrequency>(FrequencyType.EveryXPeriod);
frequency.Scale = CustomFrequencyScale.Year;
frequency.Rate = exchangeTask.Interval;
task.CustomFrequency = frequency;
}
task.UseFixedDate = exchangeTask.RecurrenceType == ExchangeRecurrencePattern.Yearly;
break;
default:
TrackingManagerHelper.Trace("ExchangeHelper - Unknown recurrence type: " + exchangeTask.RecurrenceType);
break;
}
}
}
