private static void Main(string[] args)
{
//ExchangeService service = new ExchangeService();
ExchangeService service = new ExchangeService(ExchangeVersion.Exchange2007_SP1, TimeZoneInfo.Local) { UseDefaultCredentials = true };
service.AutodiscoverUrl(@"*****@*****.**");
Task newTask = new Task(service);
newTask.Contacts.Add("*****@*****.**");
newTask.DueDate = DateTime.Now.AddDays(1);
newTask.PercentComplete = 48;
newTask.StartDate = DateTime.Now;
newTask.Status = TaskStatus.InProgress;
//newTask.TotalWork = 50;
newTask.Body = "Hello";
newTask.Subject = "Test Issue Task";
newTask.ReminderDueBy = newTask.DueDate.Value;
IList<Task> items = new List<Task>();
items.Add(newTask);
FolderId id = new FolderId(WellKnownFolderName.Tasks);
//service.CreateItems(items, id, null, null);
}
static IEnumerable <Microsoft.Exchange.WebServices.Data.Task> FindIncompleteTask(ExchangeService service)
{
// Specify the folder to search, and limit the properties returned in the result.
TasksFolder tasksfolder = TasksFolder.Bind(service,
WellKnownFolderName.Tasks,
new PropertySet(BasePropertySet.IdOnly, FolderSchema.TotalCount));
// Set the number of items to the smaller of the number of items in the Contacts folder or 1000.
int numItems = tasksfolder.TotalCount < 1000 ? tasksfolder.TotalCount : 1000;
// Instantiate the item view with the number of items to retrieve from the contacts folder.
ItemView view = new ItemView(numItems);
// To keep the request smaller, send only the display name.
view.PropertySet = new PropertySet(BasePropertySet.IdOnly, TaskSchema.Subject, TaskSchema.Status, TaskSchema.StartDate);
var filter = new SearchFilter.IsGreaterThan(TaskSchema.DateTimeCreated, DateTime.Now.AddYears(-10));
// Retrieve the items in the Tasks folder with the properties you selected.
FindItemsResults <Microsoft.Exchange.WebServices.Data.Item> taskItems = service.FindItems(WellKnownFolderName.Tasks, filter, view);
// If the subject of the task matches only one item, return that task item.
var results = new List <Microsoft.Exchange.WebServices.Data.Task>();
foreach (var task in taskItems)
{
var result = new Microsoft.Exchange.WebServices.Data.Task(service);
result = task as Microsoft.Exchange.WebServices.Data.Task;
results.Add(result);
}
return(results);
}
/// <summary>
/// Sets start and due dates for task.
/// </summary>
/// <param name="userConnection">User connection.</param>
/// <param name="startDate">Start date of task.</param>
/// <param name="dueDate">Due date of task.</param>
/// <param name="exchangeTask">Exchange task.</param>
/// <remarks>
/// When start and due dates are null,start date sets current date and due date sets start date add one day.
/// When start day is not null and due date is null,due date sets start date add one day.
/// When due day is not null and start date is null,start date sets due date minus one day.
/// </remarks>
public void SetStartAndDueDate(UserConnection userConnection, Exchange.Task exchangeTask,
out DateTime startDate, out DateTime dueDate)
{
DateTime?exchangeTaskStartDate = InitExchangeTaskDate(exchangeTask.StartDate, userConnection);
DateTime?exchangeTaskDueDate = InitExchangeTaskDate(GetExchangeTaskDueDate(exchangeTask), userConnection);
if (exchangeTaskStartDate == null)
{
if (exchangeTaskDueDate == null)
{
startDate = DateTime.Now.Date;
}
else
{
dueDate = exchangeTaskDueDate.Value.Date;
startDate = dueDate.AddDays(-1);
}
}
else
{
startDate = exchangeTaskStartDate.Value;
}
dueDate = (exchangeTaskDueDate == null)
? startDate.AddDays(1)
: exchangeTaskDueDate.Value.Date;
if (startDate >= dueDate)
{
dueDate = startDate.AddDays(1);
}
}
static IEnumerable<Microsoft.Exchange.WebServices.Data.Task> FindIncompleteTask(ExchangeService service)
{
// Specify the folder to search, and limit the properties returned in the result.
TasksFolder tasksfolder = TasksFolder.Bind(service,
WellKnownFolderName.Tasks,
new PropertySet(BasePropertySet.IdOnly, FolderSchema.TotalCount));
// Set the number of items to the smaller of the number of items in the Contacts folder or 1000.
int numItems = tasksfolder.TotalCount < 1000 ? tasksfolder.TotalCount : 1000;
// Instantiate the item view with the number of items to retrieve from the contacts folder.
ItemView view = new ItemView(numItems);
// To keep the request smaller, send only the display name.
view.PropertySet = new PropertySet(BasePropertySet.IdOnly, TaskSchema.Subject, TaskSchema.Status, TaskSchema.StartDate);
var filter = new SearchFilter.IsGreaterThan(TaskSchema.DateTimeCreated, DateTime.Now.AddYears(-10));
// Retrieve the items in the Tasks folder with the properties you selected.
FindItemsResults<Microsoft.Exchange.WebServices.Data.Item> taskItems = service.FindItems(WellKnownFolderName.Tasks, filter, view);
// If the subject of the task matches only one item, return that task item.
var results = new List<Microsoft.Exchange.WebServices.Data.Task>();
foreach (var task in taskItems)
{
var result = new Microsoft.Exchange.WebServices.Data.Task(service);
result = task as Microsoft.Exchange.WebServices.Data.Task;
results.Add(result);
}
return results;
}
/// <summary>
/// Sets<paramref name="exchangeTask"/> properties to <paramref name="activity"/>.
/// </summary>
/// <param name="activity">Activity instance.</param>
/// <param name="exchangeTask"><see cref="Exchange.Task"/> instance.</param>
/// <param name="context"><see cref="SyncContext"/> instance.</param>
/// <param name="action">Current synchronization action.</param>
protected virtual void SetActivityProperties(Entity activity, Exchange.Task exchangeTask, SyncContext context,
SyncAction action)
{
activity.SetColumnValue("ShowInScheduler", false);
DateTime startDate;
DateTime dueDate;
SetStartAndDueDate(context.UserConnection, exchangeTask, out startDate, out dueDate);
if (action == SyncAction.Update)
{
startDate = startDate.Date + activity.GetTypedColumnValue <DateTime>("StartDate").TimeOfDay;
dueDate = dueDate.Date + activity.GetTypedColumnValue <DateTime>("DueDate").TimeOfDay;
}
activity.SetColumnValue("Title", exchangeTask.Subject);
activity.SetColumnValue("StartDate", startDate);
activity.SetColumnValue("DueDate", dueDate);
activity.SetColumnValue("OwnerId", context.UserConnection.CurrentUser.ContactId);
activity.SetColumnValue("AuthorId", context.UserConnection.CurrentUser.ContactId);
activity.SetColumnValue("PriorityId", exchangeTask.Importance.GetActivityPriority());
activity.SetColumnValue("StatusId", exchangeTask.Status.GetActivityStatus());
SetActivityRemindToOwner(context, activity, exchangeTask);
if (activity.GetTypedColumnValue <bool>("RemindToOwner"))
{
activity.SetColumnValue("RemindToOwnerDate", exchangeTask.SafeGetValue <DateTime>(
Exchange.TaskSchema.ReminderDueBy).GetUserDateTime(context.UserConnection));
}
else
{
activity.SetColumnValue("RemindToOwnerDate", null);
}
activity.SetColumnValue("Notes", exchangeTask.Body.Text);
}
private void SetActivityRemindToOwner(SyncContext context, Entity activity, Exchange.Task exchangeTask)
{
try {
activity.SetColumnValue("RemindToOwner", exchangeTask.IsReminderSet);
}
catch (ServiceObjectPropertyException) {
activity.SetColumnValue("RemindToOwner", false);
LogError(context, InvalidItemPropertyMessageTemplate, "IsReminderSet");
}
}
/// <summary>
/// Checks are the properties of the <paramref name="exchangeTask"/> differ from the properties of
/// the <paramref name="activity"/>.
/// </summary>
/// <param name="exchangeTask"><see cref="Exchange.Task"/> instance.</param>
/// <param name="activity">Activity instance.</param>
/// <param name="context"><see cref="SyncContext"/> instance.</param>
/// <returns><c>True</c> if <paramref name="exchangeTask"/> properties changed. Returns <c>false</c>
/// otherwise.</returns>
protected virtual bool IsTaskChanged(Exchange.Task exchangeTask, Entity activity,
SyncContext context)
{
var userConnection = context.UserConnection;
string oldActivityHash = GetActivityHash(activity, userConnection);
EntitySchema activitySchema = userConnection.EntitySchemaManager.GetInstanceByName("Activity");
Entity newActivity = activitySchema.CreateEntity(userConnection);
SetActivityProperties(newActivity, exchangeTask, context, SyncAction.Create);
string activityHash = GetActivityHash(newActivity, userConnection);
return(activityHash != oldActivityHash);
}
private bool CheckTask(SyncContext context, Exchange.Task exchangeTask)
{
if (exchangeTask == null)
{
LogError(context, InvalidItemTypeMessageTemplate, Item.Subject);
return(false);
}
if (string.IsNullOrEmpty(exchangeTask.Subject))
{
LogError(context, InvalidItemPropertyMessageTemplate, "Subject");
return(false);
}
return(true);
}
/// <summary>
/// <see cref="ExchangeSyncProvider.EnumerateChanges"/>
/// </summary>
public override IEnumerable <IRemoteItem> EnumerateChanges(SyncContext context)
{
base.EnumerateChanges(context);
var result = new List <IRemoteItem>();
if (!UserSettings.ImportActivities)
{
return(result);
}
var folders = new List <Exchange.Folder>();
Exchange.FolderId trashFolderId = Exchange.Folder.Bind(
Service, Exchange.WellKnownFolderName.DeletedItems, Exchange.BasePropertySet.IdOnly).Id;
if (UserSettings.ImportActivitiesAll)
{
Exchange.Folder rootFolder = Exchange.Folder.Bind(Service, Exchange.WellKnownFolderName.MsgFolderRoot);
folders.GetAllFoldersByFilter(rootFolder);
folders.Add(rootFolder);
}
else
{
folders = SafeBindFolders(Service, UserSettings.RemoteFolderUIds.Keys, context);
}
Exchange.SearchFilter itemsFilter = GetItemsSearchFilters();
SyncItemSchema schema = FindSchemaBySyncValueName(typeof(ExchangeTask).Name);
foreach (Exchange.Folder folder in folders)
{
if (folder.Id.Equals(trashFolderId))
{
continue;
}
var itemView = new Exchange.ItemView(PageItemCount);
Exchange.FindItemsResults <Exchange.Item> itemCollection;
do
{
itemCollection = folder.ReadItems(itemsFilter, itemView);
foreach (Exchange.Item item in itemCollection)
{
Exchange.Task task = ExchangeUtility.SafeBindItem <Exchange.Task>(Service, item.Id);
if (task != null)
{
var remoteItem = new ExchangeTask(schema, task, TimeZone);
result.Add(remoteItem);
}
}
} while (itemCollection.MoreAvailable);
}
return(result);
}
private void button1_Click(object sender, EventArgs e)
{
Exchange.ExchangeService eService = new Exchange.ExchangeService(Exchange.ExchangeVersion.Exchange2007_SP1);
eService.Credentials = new Exchange.WebCredentials("*****@*****.**", "sFx2Dobay");
eService.Url = new Uri("https://outlook.office365.com/ews/Exchange.asmx");
//eService.TimeZone = TimeZoneInfo.Local;
//eService.ImpersonatedUserId = new Exchange.ImpersonatedUserId(Exchange.ConnectingIdType.SmtpAddress, "*****@*****.**");
Exchange.Task nTask = new Exchange.Task(eService);
Exchange.MessageBody messageBody = new Exchange.MessageBody(Exchange.BodyType.HTML, "Необходимо строчно сделать эту работу");
nTask.Body = messageBody;
nTask.Subject = "Очень важная задача";
nTask.Importance = Exchange.Importance.High;
nTask.StartDate = DateTime.Today.AddDays(1).AddHours(8);
nTask.IsReminderSet = true;
nTask.DueDate = DateTime.Today.AddDays(3).AddHours(14);
nTask.Save(new Exchange.FolderId(Exchange.WellKnownFolderName.Tasks, new Exchange.Mailbox("*****@*****.**")));
}
public override IRemoteItem LoadSyncItem(SyncItemSchema schema, string id)
{
ExchangeBase remoteItem;
Exchange.Task task = ExchangeUtility.SafeBindItem <Exchange.Task>(Service, new Exchange.ItemId(id));
if (task != null)
{
remoteItem = new ExchangeTask(schema, task, TimeZone)
{
Action = SyncAction.Update
};
}
else
{
task = new Exchange.Task(Service);
remoteItem = new ExchangeTask(schema, task, id, TimeZone)
{
State = SyncState.Deleted
};
}
return(remoteItem);
}
private void bindTasks(DateTime fromDate, DateTime toDate)
{
List <LeadTask> tasks = null;
Expression <Func <CRM.Data.Entities.Task, bool> > predicate = PredicateBuilder.True <CRM.Data.Entities.Task>();
if (roleID == (int)UserRole.Administrator)
{
}
else if ((roleID == (int)UserRole.Client || roleID == (int)UserRole.SiteAdministrator) && clientID > 0)
{
// load all tasks for client (sort of admin)
predicate = predicate.And(LeadTask => LeadTask.creator_id == clientID);
predicate = predicate.And(LeadTask => LeadTask.start_date >= fromDate && LeadTask.end_date <= toDate);
// get overdue task for client
predicate = predicate.Or(LeadTask => LeadTask.status_id == 1 && LeadTask.end_date <= toDate && LeadTask.creator_id == clientID);
}
else
{
// regular users
predicate = predicate.And(LeadTask => LeadTask.start_date >= fromDate && LeadTask.end_date <= toDate);
predicate = predicate.And(LeadTask => LeadTask.owner_id == userID);
}
tasks = TasksManager.GetLeadTask(predicate, fromDate, toDate);
if (rbOn.Checked)
{
userID = SessionHelper.getUserId();
CRM.Data.Entities.SecUser secUser = SecUserManager.GetByUserId(userID);
string emailaddress = secUser.Email;
string password = SecurityManager.Decrypt(secUser.emailPassword);
string url = "https://" + secUser.emailHost + "/EWS/Exchange.asmx";
ExchangeService service = new ExchangeService(ExchangeVersion.Exchange2007_SP1);
service.Credentials = new WebCredentials(emailaddress, password);
service.Url = new Uri(url);
try
{
TasksFolder tasksfolder = TasksFolder.Bind(service, WellKnownFolderName.Tasks);
ItemView view = new ItemView(int.MaxValue);
FindItemsResults <Item> OutlookTasks = tasksfolder.FindItems(view);
CalendarView calView = new CalendarView(fromDate, toDate);
FindItemsResults <Item> instanceResults = service.FindItems(WellKnownFolderName.Calendar, calView);
foreach (var item in instanceResults)
{
LeadTask newTask = new LeadTask();
Microsoft.Exchange.WebServices.Data.Appointment appointment = item as Microsoft.Exchange.WebServices.Data.Appointment;
newTask.creator_id = userID;
newTask.details = appointment.Subject;
newTask.end_date = appointment.End;
newTask.isAllDay = appointment.IsRecurring;
newTask.text = appointment.Subject;
newTask.priorityName = appointment.Importance.ToString();
newTask.owner_name = appointment.Organizer.Name;
newTask.start_date = appointment.Start;
tasks.Add(newTask);
}
foreach (var task in OutlookTasks)
{
task.Load();
Microsoft.Exchange.WebServices.Data.Task myTask = task as Microsoft.Exchange.WebServices.Data.Task;
LeadTask newTask = new LeadTask();
newTask.creator_id = userID;
newTask.details = ExtractHtmlInnerText(myTask.Body.Text);
newTask.end_date = myTask.DueDate;
newTask.isAllDay = myTask.IsRecurring;
newTask.text = myTask.Subject;
newTask.statusName = myTask.Status.ToString();
newTask.priorityName = myTask.Importance.ToString();
newTask.owner_name = myTask.Owner;
if (myTask.StartDate == null)
{
newTask.start_date = myTask.DueDate;
}
else
{
newTask.start_date = myTask.StartDate;
}
tasks.Add(newTask);
}
}
catch (Exception ex)
{
}
}
// show tasks
gvTasks.DataSource = tasks;
gvTasks.DataBind();
}
public string crearTareaE(string asunto, string fechaInicio, string fechaLimite, string cuerpoTarea, string correoDestino)
{
string errorTask = "";
try
{
ExchangeService service = new ExchangeService(ExchangeVersion.Exchange2010);
service.UseDefaultCredentials = true;
service.Credentials = new WebCredentials("xxxxxxxxxxx", "xxxxxx", "xxxx");
service.AutodiscoverUrl("xxxxxxxxxxxxxxx");
Task taskItem = new Task(service);
taskItem.Subject = asunto;
taskItem.Body = new MessageBody(cuerpoTarea);
taskItem.StartDate = Convert.ToDateTime(fechaInicio);
taskItem.DueDate = Convert.ToDateTime(fechaLimite);
//Aqui no se como agregar el correo destino, aun no encuentro el metodo para hacer eso.......
//taskItem.Save();
taskItem.Save();
return errorTask;
}
catch(Exception e)
{
errorTask = e.Message;
return errorTask;
}
}
public ExchangeTaskSyncData(Task exchangeTask)
{
ExchangeTask = exchangeTask;
IsFromDefault = true;
}
private ExchangeTask CreateExchangeTask(string subject, string body, DateTime dueTime, TaskStatus status)
{
var userCredential = GetExchangeUserCredential();
var exchangeService = _microsoftExchangeServiceProvider.GetMicrosoftExchangeService(userCredential);
ExchangeTask task = new ExchangeTask(exchangeService);
task.Subject = subject;
task.Body = new MessageBody(BodyType.Text, body);
task.DueDate = dueTime;
task.Status = status;
task.Importance = Importance.High;
task.Save();
task = GetExchangeTask(task.Id.UniqueId);
return task;
}
private void AssertTaskAndExchangeTaskAreEqual(CooperTask cooperTask, ExchangeTask exchangeTask)
{
MicrosoftAssert.AreEqual(cooperTask.Subject, exchangeTask.Subject);
MicrosoftAssert.AreEqual(cooperTask.Body, exchangeTask.Body.Text);
MicrosoftAssert.AreEqual(cooperTask.DueTime, exchangeTask.DueDate);
if (cooperTask.IsCompleted)
{
MicrosoftAssert.AreEqual(TaskStatus.Completed, exchangeTask.Status);
}
else
{
MicrosoftAssert.AreEqual(TaskStatus.InProgress, exchangeTask.Status);
}
MicrosoftAssert.AreEqual(cooperTask.Priority, ConvertToTaskPriority(exchangeTask.Importance));
MicrosoftAssert.AreEqual(FormatTime(cooperTask.LastUpdateTime), FormatTime(exchangeTask.LastModifiedTime));
}
private DateTime?GetExchangeTaskDueDate(Exchange.Task exchangeTask)
{
return((exchangeTask.Status == Exchange.TaskStatus.Completed)
? exchangeTask.CompleteDate
: exchangeTask.DueDate);
}
private void setExchangeTaskExtendedProperty(Exchange.Task exchangeTask, string activityId)
{
exchangeTask.SetExtendedProperty(ExchangeUtilityImpl.LocalIdProperty, activityId);
exchangeTask.Update(Exchange.ConflictResolutionMode.AlwaysOverwrite);
}
/// <summary>
/// Calls <see cref="Exchange.Item.Load(Exchange.PropertySet)"/> method for <paramref name="exchangeTask"/>.
/// </summary>
/// <param name="exchangeTask"><see cref="Exchange.Task"/> instance.</param>
/// <remarks>
/// External dependency allocation.
/// </remarks>
protected virtual void LoadItemProperties(Exchange.Task exchangeTask)
{
exchangeTask.Load(_propertySet);
}
