/// <summary>
        ///     Add appointments to destination
        /// </summary>
        /// <param name="syncProfile"></param>
        /// <param name="syncMetric"></param>
        /// <param name="destinationCalendarSpecificData"></param>
        /// <returns>
        /// </returns>
        private bool AddDestinationTasks(TaskSyncProfile syncProfile, SyncMetric syncMetric,
                                         IDictionary <string, object> destinationCalendarSpecificData)
        {
            //Update status for reading entries to add
            TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.ReadingEntriesToAdd,
                                                     DestinationTaskService.TaskServiceName);
            //Get entries to add
            TaskSyncEngine.GetDestEntriesToAdd(syncProfile, SourceTasks,
                                               DestinationTasks);
            var appointmentsToAdd = TaskSyncEngine.DestTasksToAdd;

            TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.EntriesToAdd, appointmentsToAdd.Count);
            if (appointmentsToAdd.Count == 0)
            {
                TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
                return(true);
            }
            TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.AddingEntries,
                                                     DestinationTaskService.TaskServiceName);
            //Add entries to destination calendar
            var addedTasks = DestinationTaskService.AddReminderTasks(appointmentsToAdd,
                                                                     destinationCalendarSpecificData)
                             .Result;
            var isSuccess = addedTasks.IsSuccess;

            //Update status if entries were successfully added
            TaskSyncStatus =
                StatusHelper.GetMessage(isSuccess ? SyncStateEnum.AddEntriesComplete : SyncStateEnum.AddEntriesFailed);
            TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
            if (isSuccess)
            {
                syncMetric.DestMetric.AddCount = appointmentsToAdd.Count;
                //LoadSourceId(addedTasks, SourceTasks.CalendarId);
                DestinationTasks.AddRange(addedTasks);
                if (syncProfile.SyncMode == SyncModeEnum.TwoWay)
                {
                    //Add appointments to update
                    //var updateSourceList = UpdateWithChildId(addedTasks, SourceTasks);
                    //TaskSyncEngine.SourceTasksToUpdate.AddRangeCompareForUpdate(updateSourceList);
                }
            }
            return(isSuccess);
        }
        /// <summary>
        ///     Delete appointments in destination
        /// </summary>
        /// <param name="syncProfile"></param>
        /// <param name="syncMetric"></param>
        /// <param name="destinationCalendarSpecificData"></param>
        /// <param name="syncCallback"></param>
        /// <returns>
        /// </returns>
        private bool DeleteDestinationTasks(TaskSyncProfile syncProfile, SyncMetric syncMetric,
                                            IDictionary <string, object> destinationCalendarSpecificData, SyncCallback syncCallback)
        {
            //if (syncProfile.SyncSettings.DisableDelete)
            //{
            //    return true;
            //}
            //Updating entry isDeleteOperation status
            TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
            TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.ReadingEntriesToDelete,
                                                     DestinationTaskService.TaskServiceName);
            //Getting appointments to isDeleteOperation
            TaskSyncEngine.GetDestEntriesToDelete(syncProfile,
                                                  SourceTasks, DestinationTasks);
            var appointmentsToDelete = TaskSyncEngine.DestTasksToDelete;

            if (syncProfile.SyncMode == SyncModeEnum.OneWay)
            {
                //if (syncProfile.SyncSettings.ConfirmOnDelete && syncCallback != null)
                //{
                //    var orphanEntries = Environment.NewLine +
                //                        string.Join(Environment.NewLine, TaskSyncEngine.DestOrphanEntries);
                //    //Log Orphan Entries
                //    Logger.Warn("Orphan entries to delete: " + orphanEntries);

                //    var message = string.Format("Are you sure you want to delete {0} orphan entries from {1}?{2}",
                //        appointmentsToDelete.Count, DestinationTaskService.TaskServiceName,
                //        orphanEntries);
                //    var e = new SyncEventArgs(message, UserActionEnum.ConfirmDelete);

                //    var task = syncCallback(e);
                //    if (task.Result)
                //    {
                //        appointmentsToDelete.AddRange(TaskSyncEngine.DestOrphanEntries);
                //    }
                //}
                //else if (!syncProfile.SyncSettings.DisableDelete)
                //{
                //    appointmentsToDelete.AddRange(TaskSyncEngine.DestOrphanEntries);
                //}
            }

            //Updating Get entry isDeleteOperation status
            TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.EntriesToDelete, appointmentsToDelete.Count);

            if (appointmentsToDelete.Count == 0)
            {
                TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
                return(true);
            }

            //Updating isDeleteOperation status
            TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DeletingEntries,
                                                     DestinationTaskService.TaskServiceName);

            //Deleting entries

            var deletedTasks = DestinationTaskService.DeleteReminderTasks(appointmentsToDelete, destinationCalendarSpecificData)
                               .Result;
            var isSuccess = deletedTasks.IsSuccess;

            //Update status if entries were successfully deleted
            TaskSyncStatus =
                StatusHelper.GetMessage(isSuccess
                    ? SyncStateEnum.DeletingEntriesComplete
                    : SyncStateEnum.DeletingEntriesFailed);
            TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
            if (isSuccess)
            {
                syncMetric.DestMetric.DeleteCount       = appointmentsToDelete.Count;
                syncMetric.DestMetric.DeleteFailedCount = appointmentsToDelete.Count - deletedTasks.Count;
                for (var index = 0; index < appointmentsToDelete.Count; index++)
                {
                    DestinationTasks.Remove(appointmentsToDelete[index]);
                }
            }

            return(isSuccess);
        }