示例#1
0
        /// <summary>
        /// 更新排序
        /// </summary>
        /// <returns></returns>
        public async Task UpdateOrderAsync()
        {
            IsLoading = Visibility.Visible;
            await CloudService.UpdateAllOrderAsync(ToDo.GetCurrentOrderString(AllToDos));

            IsLoading = Visibility.Collapsed;
        }
示例#2
0
        /// <summary>
        /// 完成待办事项
        /// </summary>
        /// <param name="id">待办事项的ID</param>
        /// <returns></returns>
        private async Task CompleteTodo(ToDo todo)
        {
            IsLoading = Visibility.Visible;

            try
            {
                var item = todo;
                item.IsDone = !item.IsDone;

                await SerializerHelper.SerializerToJson <ObservableCollection <ToDo> >(AllToDos, "myschedules.sch");

                if (App.CanSendRequest)
                {
                    var result = await CloudService.FinishToDoAsync(todo.ID, item.IsDone? "1" : "0");

                    if (result)
                    {
                        await CloudService.UpdateAllOrderAsync(ToDo.GetCurrentOrderString(AllToDos));
                    }
                }
                Messenger.Default.Send(new GenericMessage <ObservableCollection <ToDo> >(AllToDos), MessengerTokens.UpdateTile);

                UpdateUndoneCount();
            }
            catch (Exception ex)
            {
                var task = Logger.LogAsync(ex);
            }
            finally
            {
                IsLoading = Visibility.Collapsed;
            }
        }
示例#3
0
        /// <summary>
        /// 重新发送暂存区的ToDo
        /// </summary>
        /// <returns></returns>
        private async Task ReSendStagedToDos()
        {
            if (StagedToDos.Count == 0)
            {
                return;
            }

            foreach (var item in StagedToDos)
            {
                var result = await CloudService.AddToDoAsync(item.Content, "0", item.Category.ToString());
            }

            await CloudService.UpdateAllOrderAsync(ToDo.GetCurrentOrderString(AllToDos));

            StagedToDos.Clear();
            await SerializerHelper.SerializerToJson <ObservableCollection <ToDo> >(StagedToDos, SerializerFileNames.StageFileName);
        }
示例#4
0
        /// <summary>
        /// 删除todo
        /// </summary>
        /// <param name="id">ID</param>
        /// <returns></returns>
        /// 先从列表删除,然后把列表内容都序列化保存,接着:
        /// 1.如果已经登陆的,尝试发送请求;
        /// 2.离线模式,不用管
        private async Task DeleteToDo(ToDo todo)
        {
            IsLoading = Visibility.Visible;

            try
            {
                var item = todo;

                DeletedToDos.Add(item);
                await SerializerHelper.SerializerToJson <ObservableCollection <ToDo> >(DeletedToDos, SerializerFileNames.DeletedFileName);

                AllToDos.Remove(item);

                UpdateDisplayList(CateVM.Categories[SelectedCate].CateColorID);
                await SerializerHelper.SerializerToJson <ObservableCollection <ToDo> >(AllToDos, SerializerFileNames.ToDoFileName);

                //登录过的
                if (App.CanSendRequest)
                {
                    var result = await CloudService.DeleteToDoAsync(todo.ID);

                    await CloudService.UpdateAllOrderAsync(ToDo.GetCurrentOrderString(AllToDos));
                }

                Messenger.Default.Send(new GenericMessage <ObservableCollection <ToDo> >(AllToDos), MessengerTokens.UpdateTile);

                UpdateUndoneCount();
            }
            catch (Exception e)
            {
                var task = Logger.LogAsync(e);
            }
            finally
            {
                IsLoading = Visibility.Collapsed;
            }
        }
示例#5
0
        /// <summary>
        /// 添加待办事项
        /// </summary>
        /// <returns></returns>
        private async Task AddOrRestoreAndSyncNewToDo(int?category = null)
        {
            ShowNoItems = Visibility.Collapsed;

            EditedToDo.ID = Guid.NewGuid().ToString();
            if (category == null)
            {
                EditedToDo.Category = CateVM.Categories[AddingCate].CateColorID;
            }

            //0 for insert,1 for add
            if (!AppSettings.Instance.IsAddToBottom)
            {
                AllToDos.Insert(0, EditedToDo);
            }
            else
            {
                AllToDos.Add(EditedToDo);
            }

            //序列化保存
            await SerializerHelper.SerializerToJson <ObservableCollection <ToDo> >(AllToDos, SerializerFileNames.ToDoFileName);

            //更新磁贴
            Messenger.Default.Send(new GenericMessage <ObservableCollection <ToDo> >(AllToDos), MessengerTokens.UpdateTile);

            //离线模式,还没有登录过
            if (App.IsInOfflineMode)
            {
                IsLoading = Visibility.Collapsed;
            }
            //登录过的,但是没有网络
            else if (App.IsNoNetwork && !App.IsInOfflineMode)
            {
                StagedToDos.Add(EditedToDo);
                await SerializerHelper.SerializerToJson <ObservableCollection <ToDo> >(StagedToDos, SerializerFileNames.StageFileName);
            }
            //登录过的,有网络
            else if (App.CanSendRequest)
            {
                try
                {
                    //在线模式
                    //发送请求
                    var result = await CloudService.AddToDoAsync(EditedToDo.Content, "0", EditedToDo.Category.ToString());

                    if (!string.IsNullOrEmpty(result.JsonSrc))
                    {
                        ////发送当前的顺序
                        await CloudService.UpdateAllOrderAsync(ToDo.GetCurrentOrderString(AllToDos));
                    }
                    else
                    {
                        StagedToDos.Add(EditedToDo);
                    }
                }
                catch (Exception)
                {
                    StagedToDos.Add(EditedToDo);
                }
            }
            EditedToDo = new ToDo();
            IsLoading  = Visibility.Collapsed;
            UpdateListByChangingSelectedCate();
            UpdateUndoneCount();
        }