예제 #1
0
        public async Task GetServiceArticles(AccessToken token, int position, int pageIndex = 1)
        {
            try
            {
                var url = "";
                switch (position)
                {
                case 0:
                    url = string.Format(ApiUtils.ArticleHome, pageIndex, pageSize);
                    break;

                case 1:
                    url = string.Format(ApiUtils.ArticleHot, pageIndex, pageSize);
                    break;
                }
                var result = await OkHttpUtils.Instance(token).GetAsyn(url);

                if (result.IsError)
                {
                    articlesView.GetServiceArticlesFail(result.Message);
                }
                else
                {
                    var articles = JsonConvert.DeserializeObject <List <ArticlesModel> >(result.Message);
                    await SQLiteUtils.Instance().UpdateArticles(articles);

                    articlesView.GetServiceArticlesSuccess(articles);
                }
            }
            catch (Exception ex)
            {
                articlesView.GetServiceArticlesFail(ex.Message);
            }
        }
예제 #2
0
        public async Task GetServiceNews(AccessToken token, int id)
        {
            try
            {
                var result = await OkHttpUtils.Instance(token).GetAsyn(string.Format(ApiUtils.NewsBody, id));

                if (result.IsError)
                {
                    newsView.GetServiceNewsFail(result.Message);
                }
                else
                {
                    await SQLiteUtils.Instance().QueryNew(id).ContinueWith(async(response) =>
                    {
                        var news  = response.Result;
                        news.Body = result.Message;
                        await SQLiteUtils.Instance().UpdateNew(news);
                        newsView.GetServiceNewsSuccess(news);
                    });
                }
            }
            catch (Exception ex)
            {
                newsView.GetServiceNewsFail(ex.Message);
            }
        }
예제 #3
0
        public void UserRefreshToken(AccessToken token, string basic)
        {
            try
            {
                var param = new List <OkHttpUtils.Param>()
                {
                    new OkHttpUtils.Param("grant_type", "refresh_token"),
                    new OkHttpUtils.Param("refresh_token", token.refresh_token)
                };

                OkHttpUtils.Instance(token).Post(ApiUtils.Token, basic, param, async(call, response) =>
                {
                    var code = response.Code();
                    var body = await response.Body().StringAsync();
                    if (code == (int)System.Net.HttpStatusCode.OK)
                    {
                        token             = JsonConvert.DeserializeObject <AccessToken>(body);
                        token.RefreshTime = DateTime.Now;

                        UserShared.Update(context, token);
                    }
                    else
                    {
                        UserShared.Update(context, new AccessToken());
                    }
                }, (call, ex) =>
                {
                });
            }
            catch (Exception ex)
            {
            }
        }
예제 #4
0
        public async Task GetServiceKbArticle(AccessToken token, int id)
        {
            try
            {
                var result = await OkHttpUtils.Instance(token).GetAsyn(string.Format(ApiUtils.KbArticlesBody, id));

                if (result.IsError)
                {
                    kbarticleView.GetServiceKbArticleFail(result.Message);
                }
                else
                {
                    await SQLiteUtils.Instance().QueryKbArticle(id).ContinueWith(async(response) =>
                    {
                        var article  = response.Result;
                        article.Body = result.Message;
                        await SQLiteUtils.Instance().UpdateKbArticle(article);
                        kbarticleView.GetServiceKbArticleSuccess(article);
                    });
                }
            }
            catch (Exception ex)
            {
                kbarticleView.GetServiceKbArticleFail(ex.Message);
            }
        }
예제 #5
0
 public async Task LoginAsync(AccessToken token, string basic, string account, string password)
 {
     try
     {
         var param = new List <OkHttpUtils.Param>()
         {
             new OkHttpUtils.Param("grant_type", "password"),
             new OkHttpUtils.Param("username", account),
             new OkHttpUtils.Param("password", password)
         };
         OkHttpUtils.Instance(token).Post(ApiUtils.Token, basic, param, async(call, response) =>
         {
             var code = response.Code();
             var body = await response.Body().StringAsync();
             if (code == (int)System.Net.HttpStatusCode.OK)
             {
                 token             = JsonConvert.DeserializeObject <AccessToken>(body);
                 token.RefreshTime = DateTime.Now;
                 var result        = await OkHttpUtils.Instance(token).GetAsyn(ApiUtils.Users);
                 if (result.IsError)
                 {
                     loginView.LoginFail(result.Message);
                 }
                 else
                 {
                     var user = JsonConvert.DeserializeObject <UserModel>(result.Message);
                     await SQLiteUtils.Instance().UpdateUser(user);
                     loginView.LoginSuccess(token, user);
                 }
             }
             else
             {
                 try
                 {
                     var error = JsonConvert.DeserializeObject <LoginErrorMessage>(body);
                     if (error != null && error.Error != null)
                     {
                         loginView.LoginFail("µÇ¼ʧ°Ü,Óû§Ãû»òÃÜÂë´íÎó");
                     }
                 }
                 catch (Exception e)
                 {
                     loginView.LoginFail(e.Message);
                 }
             }
         }, (call, ex) =>
         {
             loginView.LoginFail(ex.Message);
         });
     }
     catch (Exception ex)
     {
         loginView.LoginFail(ex.Message);
     }
 }
예제 #6
0
        public void PostComment(AccessToken token, int questionId, int answerId, string content)
        {
            try
            {
                var url = string.Format(ApiUtils.QuestionsAnswerCommentsAdd, questionId, answerId.ToString());

                var param = new List <OkHttpUtils.Param>()
                {
                    new OkHttpUtils.Param("ParentCommentId", "0"),
                    new OkHttpUtils.Param("Content", content),
                };

                OkHttpUtils.Instance(token).Post(url, param, async(call, response) =>
                {
                    var code = response.Code();
                    var body = await response.Body().StringAsync();
                    if (code == (int)System.Net.HttpStatusCode.OK)
                    {
                        var user = await SQLiteUtils.Instance().QueryUser();
                        QuestionCommentsModel news = new QuestionCommentsModel();
                        news.PostUserInfo          = new QuestionUserInfoModel()
                        {
                            UserID   = user.SpaceUserId,
                            IconName = user.Face,
                            UCUserID = user.UserId,
                            UserName = user.DisplayName,
                            QScore   = user.Score
                        };
                        news.Content   = content;
                        news.DateAdded = DateTime.Now;
                        news.CommentID = answerId;
                        commentsView.PostCommentSuccess(news);
                    }
                    else
                    {
                        try
                        {
                            var error = JsonConvert.DeserializeObject <ErrorMessage>(body);
                            commentsView.PostCommentFail(error.Message);
                        }
                        catch (Exception e)
                        {
                            commentsView.PostCommentFail(e.Message);
                        }
                    }
                }, (call, ex) =>
                {
                    commentsView.PostCommentFail(ex.Message);
                });
            }
            catch (Exception e)
            {
                commentsView.PostCommentFail(e.Message);
            }
        }
예제 #7
0
        public void PostComment(AccessToken token, int id, string content)
        {
            try
            {
                var url = string.Format(ApiUtils.NewsCommentAdd, id.ToString());

                var param = new List <OkHttpUtils.Param>()
                {
                    new OkHttpUtils.Param("ParentId", "0"),
                    new OkHttpUtils.Param("Content", content),
                };

                OkHttpUtils.Instance(token).Post(url, param, async(call, response) =>
                {
                    var code = response.Code();
                    var body = await response.Body().StringAsync();
                    if (code == (int)System.Net.HttpStatusCode.Created)
                    {
                        var user = await SQLiteUtils.Instance().QueryUser();
                        NewsCommentModel news = new NewsCommentModel();
                        news.UserName         = user.DisplayName;
                        news.FaceUrl          = user.Face;
                        news.CommentContent   = content;
                        news.DateAdded        = DateTime.Now;
                        news.Floor            = 0;
                        news.CommentID        = Convert.ToInt32(body);
                        news.AgreeCount       = 0;
                        news.AntiCount        = 0;
                        news.ContentID        = 0;
                        news.UserGuid         = user.UserId;
                        commentView.PostCommentSuccess(news);
                    }
                    else
                    {
                        try
                        {
                            var error = JsonConvert.DeserializeObject <ErrorMessage>(body);
                            commentView.PostCommentFail(error.Message);
                        }
                        catch (Exception e)
                        {
                            commentView.PostCommentFail(e.Message);
                        }
                    }
                }, (call, ex) =>
                {
                    commentView.PostCommentFail(ex.Message);
                });
            }
            catch (Exception e)
            {
                commentView.PostCommentFail(e.Message);
            }
        }
예제 #8
0
        public void StatusAdd(AccessToken token, string content, bool isPrivate)
        {
            try
            {
                var url = ApiUtils.StatusADD;

                var param = new List <OkHttpUtils.Param>()
                {
                    new OkHttpUtils.Param("IsPrivate", isPrivate.ToString()),
                    new OkHttpUtils.Param("Content", content),
                };

                OkHttpUtils.Instance(token).Post(url, param, async(call, response) =>
                {
                    var code = response.Code();
                    var body = await response.Body().StringAsync();
                    if (code == (int)System.Net.HttpStatusCode.OK)
                    {
                        var user               = await SQLiteUtils.Instance().QueryUser();
                        StatusModel status     = new StatusModel();
                        status.UserDisplayName = user.DisplayName;
                        status.UserIconUrl     = user.Face;
                        status.Content         = content;
                        status.IsPrivate       = isPrivate;
                        status.DateAdded       = DateTime.Now;
                        status.UserGuid        = user.UserId;
                        statusView.StatusAddSuccess(status);
                    }
                    else
                    {
                        try
                        {
                            var error = JsonConvert.DeserializeObject <ErrorMessage>(body);
                            statusView.StatusAddFail(error.Message);
                        }
                        catch (Exception e)
                        {
                            statusView.StatusAddFail(e.Message);
                        }
                    }
                }, (call, ex) =>
                {
                    statusView.StatusAddFail(ex.Message);
                });
            }
            catch (Exception e)
            {
                statusView.StatusAddFail(e.Message);
            }
        }
예제 #9
0
        public void BookmarkEdit(AccessToken token, BookmarksModel bookmark, int position)
        {
            try
            {
                var url = string.Format(ApiUtils.BookmarkEdit, bookmark.WzLinkId);

                var param = new List <OkHttpUtils.Param>()
                {
                    new OkHttpUtils.Param("WzLinkId", bookmark.WzLinkId.ToString()),
                    new OkHttpUtils.Param("LinkUrl", bookmark.LinkUrl),
                    new OkHttpUtils.Param("Title", bookmark.Title),
                    new OkHttpUtils.Param("Summary", bookmark.Summary),
                    new OkHttpUtils.Param("Tags", bookmark.Tag),
                    new OkHttpUtils.Param("DateAdded", bookmark.DateAdded.ToString()),
                    new OkHttpUtils.Param("FromCNBlogs", bookmark.FromCNBlogs.ToString())
                };

                OkHttpUtils.Instance(token).Patch(url, param, async(call, response) =>
                {
                    var code = response.Code();
                    var body = await response.Body().StringAsync();
                    if (code == (int)System.Net.HttpStatusCode.OK)
                    {
                        await SQLiteUtils.Instance().UpdateBookmark(bookmark);
                        bookmarkView.BookmarkEditSuccess(position);
                    }
                    else
                    {
                        try
                        {
                            var error = JsonConvert.DeserializeObject <ErrorMessage>(body);
                            bookmarkView.BookmarkEditFail(error.Message);
                        }
                        catch (Exception e)
                        {
                            bookmarkView.BookmarkEditFail(e.Message);
                        }
                    }
                }, (call, ex) =>
                {
                    bookmarkView.BookmarkEditFail(ex.Message);
                });
            }
            catch (Exception e)
            {
                bookmarkView.BookmarkEditFail(e.Message);
            }
        }
        public async Task GetServiceQuestions(AccessToken token, int position, int pageIndex = 1)
        {
            try
            {
                string url = "";
                switch (position)
                {
                case 0:
                    url = string.Format(ApiUtils.Questions, pageIndex, pageSize);
                    break;

                case 1:
                    url = string.Format(ApiUtils.QuestionsType, "highscore", pageIndex, pageSize);
                    break;

                case 2:
                    url = string.Format(ApiUtils.QuestionsType, "noanswer", pageIndex, pageSize);
                    break;

                case 3:
                    url = string.Format(ApiUtils.QuestionsType, "solved", pageIndex, pageSize);
                    break;

                case 4:
                    url = string.Format(ApiUtils.QuestionsType, "myquestion", pageIndex, pageSize);
                    break;
                }
                var result = await OkHttpUtils.Instance(token).GetAsyn(url);

                if (result.IsError)
                {
                    questionView.GetServiceQuestionsFail(result.Message);
                }
                else
                {
                    var questions = JsonConvert.DeserializeObject <List <QuestionsModel> >(result.Message);
                    if (position != 4)
                    {
                        await SQLiteUtils.Instance().UpdateQuestions(questions);
                    }
                    questionView.GetServiceQuestionsSuccess(questions);
                }
            }
            catch (Exception ex)
            {
                questionView.GetServiceQuestionsFail(ex.Message);
            }
        }
예제 #11
0
        public async Task GetServiceNews(AccessToken token, int position, int pageIndex = 1)
        {
            try
            {
                var url = "";
                switch (position)
                {
                case 0:
                    url = string.Format(ApiUtils.NewsHome, pageIndex, pageSize);
                    break;

                case 1:
                    url = string.Format(ApiUtils.NewsRecommend, pageIndex, pageSize);
                    break;

                case 2:
                    url = string.Format(ApiUtils.NewsWorkHot, pageIndex, pageSize);
                    break;
                }
                var result = await OkHttpUtils.Instance(token).GetAsyn(url);

                if (result.IsError)
                {
                    newsView.GetServiceNewsFail(result.Message);
                }
                else
                {
                    var news = JsonConvert.DeserializeObject <List <NewsModel> >(result.Message);
                    switch (position)
                    {
                    case 1:
                        news.ForEach(s => s.IsRecommend = true);
                        break;

                    case 2:
                        news.ForEach(s => s.IsHot = true);
                        break;
                    }
                    await SQLiteUtils.Instance().UpdateNews(news);

                    newsView.GetServiceNewsSuccess(news);
                }
            }
            catch (Exception ex)
            {
                newsView.GetServiceNewsFail(ex.Message);
            }
        }
예제 #12
0
        public void BookmarkAdd(AccessToken token, BookmarksModel bookmark)
        {
            try
            {
                var url = ApiUtils.BookmarkAdd;

                var param = new List <OkHttpUtils.Param>()
                {
                    new OkHttpUtils.Param("LinkUrl", bookmark.LinkUrl),
                    new OkHttpUtils.Param("Title", bookmark.Title),
                    new OkHttpUtils.Param("Summary", bookmark.Summary),
                    new OkHttpUtils.Param("Tags", bookmark.Tag),
                    new OkHttpUtils.Param("FromCNBlogs", bookmark.FromCNBlogs.ToString())
                };

                OkHttpUtils.Instance(token).Post(url, param, async(call, response) =>
                {
                    var code = response.Code();
                    var body = await response.Body().StringAsync();
                    if (code == (int)System.Net.HttpStatusCode.Created)
                    {
                        bookmarkView.BookmarkAddSuccess();
                    }
                    else
                    {
                        try
                        {
                            var error = JsonConvert.DeserializeObject <ErrorMessage>(body);
                            bookmarkView.BookmarkAddFail(error.Message);
                        }
                        catch (Exception e)
                        {
                            bookmarkView.BookmarkAddFail(e.Message);
                        }
                    }
                }, (call, ex) =>
                {
                    bookmarkView.BookmarkAddFail(ex.Message);
                });
            }
            catch (Exception e)
            {
                bookmarkView.BookmarkAddFail(e.Message);
            }
        }
예제 #13
0
        public void QuestionAdd(AccessToken token, string title, string content, string tags, int flags)
        {
            try
            {
                var url = string.Format(ApiUtils.QuestionADD);

                var param = new List <OkHttpUtils.Param>()
                {
                    new OkHttpUtils.Param("Title", title),
                    new OkHttpUtils.Param("Content", content),
                    new OkHttpUtils.Param("Tags", tags),
                    new OkHttpUtils.Param("Flags", flags.ToString()),
                };

                OkHttpUtils.Instance(token).Post(url, param, async(call, response) =>
                {
                    var code = response.Code();
                    var body = await response.Body().StringAsync();
                    if (code == (int)System.Net.HttpStatusCode.OK)
                    {
                        questionView.QuestionAddSuccess(null);
                    }
                    else
                    {
                        try
                        {
                            var error = JsonConvert.DeserializeObject <ErrorMessage>(body);
                            questionView.QuestionAddFail(error.Message);
                        }
                        catch (Exception e)
                        {
                            questionView.QuestionAddFail(e.Message);
                        }
                    }
                }, (call, ex) =>
                {
                    questionView.QuestionAddFail(ex.Message);
                });
            }
            catch (Exception e)
            {
                questionView.QuestionAddFail(e.Message);
            }
        }
 public void PostComment(AccessToken token, string blogApp, int id, string content)
 {
     try
     {
         var url = string.Format(ApiUtils.ArticleCommentAdd, blogApp, id);
         OkHttpUtils.Instance(token).Post(url, content, async(call, response) =>
         {
             var code = response.Code();
             var body = await response.Body().StringAsync();
             if (code == (int)System.Net.HttpStatusCode.OK)
             {
                 var user = await SQLiteUtils.Instance().QueryUser();
                 ArticleCommentModel article = new ArticleCommentModel();
                 article.Author    = user.DisplayName;
                 article.AuthorUrl = user.Avatar;
                 article.FaceUrl   = user.Face;
                 article.Body      = content;
                 article.DateAdded = DateTime.Now;
                 article.Floor     = 0;
                 article.Id        = 0;
                 commentView.PostCommentSuccess(article);
             }
             else
             {
                 try
                 {
                     var error = JsonConvert.DeserializeObject <ErrorMessage>(body);
                     commentView.PostCommentFail(error.Message);
                 }
                 catch (Exception e)
                 {
                     commentView.PostCommentFail(e.Message);
                 }
             }
         }, (call, ex) =>
         {
             commentView.PostCommentFail(ex.Message);
         });
     }
     catch (Exception e)
     {
         commentView.PostCommentFail(e.Message);
     }
 }
예제 #15
0
        public void AnswersAdd(AccessToken token, int questionId, string content)
        {
            try
            {
                var url = string.Format(ApiUtils.QuestionsAnswerAdd, questionId);

                var param = new List <OkHttpUtils.Param>()
                {
                    new OkHttpUtils.Param("Answer", content),
                };

                OkHttpUtils.Instance(token).Post(url, param, async(call, response) =>
                {
                    var code = response.Code();
                    var body = await response.Body().StringAsync();
                    if (code == (int)System.Net.HttpStatusCode.OK)
                    {
                        answersView.AnswersAddSuccess(null);
                    }
                    else
                    {
                        try
                        {
                            var error = JsonConvert.DeserializeObject <ErrorMessage>(body);
                            answersView.AnswersAddFail(error.Message);
                        }
                        catch (Exception e)
                        {
                            answersView.AnswersAddFail(e.Message);
                        }
                    }
                }, (call, ex) =>
                {
                    answersView.AnswersAddFail(ex.Message);
                });
            }
            catch (Exception e)
            {
                answersView.AnswersAddFail(e.Message);
            }
        }
예제 #16
0
        public async Task GetComment(AccessToken token, int id, int pageIndex = 1)
        {
            try
            {
                var result = await OkHttpUtils.Instance(token).GetAsyn(string.Format(ApiUtils.NewsComment, id, pageIndex, pageSize));

                if (result.IsError)
                {
                    commentView.GetCommentFail(result.Message);
                }
                else
                {
                    var comments = JsonConvert.DeserializeObject <List <NewsCommentModel> >(result.Message);
                    commentView.GetCommentSuccess(comments);
                }
            }
            catch (Exception ex)
            {
                commentView.GetCommentFail(ex.Message);
            }
        }
예제 #17
0
        public async Task GetServiceNews(AccessToken token, int pageIndex = 1)
        {
            try
            {
                var result = await OkHttpUtils.Instance(token).GetAsyn(string.Format(ApiUtils.News, pageIndex, pageSize));

                if (result.IsError)
                {
                    newsView.GetServiceNewsFail(result.Message);
                }
                else
                {
                    var news = JsonConvert.DeserializeObject <List <NewsModel> >(result.Message);
                    newsView.GetServiceNewsSuccess(news);
                }
            }
            catch (Exception ex)
            {
                newsView.GetServiceNewsFail(ex.Message);
            }
        }
        public async Task GetAnswers(AccessToken token, int id, int pageIndex = 1)
        {
            try
            {
                var result = await OkHttpUtils.Instance(token).GetAsyn(string.Format(ApiUtils.QuestionsAnswers, id));

                if (result.IsError)
                {
                    answersView.GetAnswersFail(result.Message);
                }
                else
                {
                    var answers = JsonConvert.DeserializeObject <List <QuestionAnswersModel> >(result.Message);
                    answersView.GetAnswersSuccess(answers);
                }
            }
            catch (Exception ex)
            {
                answersView.GetAnswersFail(ex.Message);
            }
        }
예제 #19
0
        public async Task GetServiceComments(AccessToken token, int id)
        {
            try
            {
                var result = await OkHttpUtils.Instance(token).GetAsyn(string.Format(ApiUtils.QuestionsAnswerComments, id));

                if (result.IsError)
                {
                    commentsView.GetCommentsFail(result.Message);
                }
                else
                {
                    var comments = JsonConvert.DeserializeObject <List <QuestionCommentsModel> >(result.Message);
                    commentsView.GetCommentsSuccess(comments);
                }
            }
            catch (Exception ex)
            {
                commentsView.GetCommentsFail(ex.Message);
            }
        }
예제 #20
0
 public void GetAccessToken(AccessToken token, string basic)
 {
     try
     {
         var param = new List <OkHttpUtils.Param>()
         {
             new OkHttpUtils.Param("grant_type", "client_credentials")
         };
         OkHttpUtils.Instance(token).Post(ApiUtils.Token, basic, param, async(call, response) =>
         {
             var code = response.Code();
             var body = await response.Body().StringAsync();
             if (code == (int)System.Net.HttpStatusCode.OK)
             {
                 token             = JsonConvert.DeserializeObject <AccessToken>(body);
                 token.RefreshTime = DateTime.Now;
                 splashView.GetAccessTokenSuccess(token);
             }
             else
             {
                 try
                 {
                     var error = JsonConvert.DeserializeObject <ErrorMessage>(body);
                     splashView.GetAccessTokenFail(error.Message);
                 }
                 catch (Exception e)
                 {
                     splashView.GetAccessTokenFail(e.Message);
                 }
             }
         }, (call, ex) =>
         {
             splashView.GetAccessTokenFail(ex.Message);
         });
     }
     catch (Exception ex)
     {
         splashView.GetAccessTokenFail(ex.Message);
     }
 }
예제 #21
0
        public async void CheckAnswersByUser(AccessToken token, int questionId)
        {
            try
            {
                var user = await SQLiteUtils.Instance().QueryUser();

                var url = string.Format(ApiUtils.QuestionsAnswerByUser, questionId, user.SpaceUserId);

                if (await OkHttpUtils.Instance(token).HeadAsyn(url))
                {
                    answersView.CheckAnswersUserSuccess();
                }
                else
                {
                    answersView.CheckAnswersUserFail(null);
                }
            }
            catch (Exception e)
            {
                answersView.CheckAnswersUserFail(e.Message);
            }
        }
예제 #22
0
 public void Login(AccessToken token, string content)
 {
     try
     {
         OkHttpUtils.Instance(token).Post(ApiUtils.Token, content, "application/x-www-form-urlencoded", async(call, response) =>
         {
             var code = response.Code();
             var body = await response.Body().StringAsync();
             if (code == (int)System.Net.HttpStatusCode.OK)
             {
                 token             = JsonConvert.DeserializeObject <AccessToken>(body);
                 token.RefreshTime = DateTime.Now;
                 var result        = await OkHttpUtils.Instance(token).GetAsyn(ApiUtils.Users);
                 if (result.IsError)
                 {
                     loginView.LoginFail(result.Message);
                 }
                 else
                 {
                     var user = JsonConvert.DeserializeObject <UserModel>(result.Message);
                     await SQLiteUtils.Instance().UpdateUser(user);
                     loginView.LoginSuccess(token, user);
                 }
             }
             else
             {
                 loginView.LoginFail("»ñÈ¡tokenʧ°Ü");
             }
         }, (call, ex) =>
         {
             loginView.LoginFail(ex.Message);
         });
     }
     catch (Exception ex)
     {
         loginView.LoginFail(ex.Message);
     }
 }
예제 #23
0
        public async Task GetServiceBookmarks(AccessToken token, int pageIndex = 1)
        {
            try
            {
                var result = await OkHttpUtils.Instance(token).GetAsyn(string.Format(ApiUtils.Bookmarks, pageIndex, pageSize));

                if (result.IsError)
                {
                    bookmarksView.GetServiceBookmarksFail(result.Message);
                }
                else
                {
                    var bookmarks = JsonConvert.DeserializeObject <List <BookmarksModel> >(result.Message);
                    await SQLiteUtils.Instance().UpdateBookmarks(bookmarks);

                    bookmarksView.GetServiceBookmarksSuccess(bookmarks);
                }
            }
            catch (Exception ex)
            {
                bookmarksView.GetServiceBookmarksFail(ex.Message);
            }
        }
예제 #24
0
        public async Task GetServiceBlogPosts(AccessToken token, string blogApp, int pageIndex)
        {
            try
            {
                var result = await OkHttpUtils.Instance(token).GetAsyn(string.Format(ApiUtils.BlogPosts, blogApp, pageIndex));

                if (result.IsError)
                {
                    blogView.GetServiceBlogPostsFail(result.Message);
                }
                else
                {
                    var articles = JsonConvert.DeserializeObject <List <ArticlesModel> >(result.Message);
                    await SQLiteUtils.Instance().UpdateArticles(articles);

                    blogView.GetServiceBlogPostsSuccess(articles);
                }
            }
            catch (Exception ex)
            {
                blogView.GetServiceBlogPostsFail(ex.Message);
            }
        }
예제 #25
0
        public async Task GetServiceStatus(AccessToken token, int id)
        {
            try
            {
                var result = await OkHttpUtils.Instance(token).GetAsyn(string.Format(ApiUtils.StatusBody, id));

                if (result.IsError)
                {
                    statusView.GetServiceStatusFail(result.Message);
                }
                else
                {
                    var status = JsonConvert.DeserializeObject <StatusModel>(result.Message);
                    await SQLiteUtils.Instance().UpdateStatus(status);

                    statusView.GetServiceStatusSuccess(status);
                }
            }
            catch (Exception e)
            {
                statusView.GetServiceStatusFail(e.Message);
            }
        }
예제 #26
0
        public async Task GetServiceQuestion(AccessToken token, int id)
        {
            try
            {
                var result = await OkHttpUtils.Instance(token).GetAsyn(string.Format(ApiUtils.QuestionDetails, id));

                if (result.IsError)
                {
                    questionView.GetServiceQuestionFail(result.Message);
                }
                else
                {
                    var question = JsonConvert.DeserializeObject <QuestionsModel>(result.Message);
                    await SQLiteUtils.Instance().UpdateQuestion(question);

                    questionView.GetServiceQuestionSuccess(question);
                }
            }
            catch (Exception ex)
            {
                questionView.GetServiceQuestionFail(ex.Message);
            }
        }
예제 #27
0
        public async void DeleteBookmarkAsync(AccessToken token, int id)
        {
            try
            {
                var url = string.Format(ApiUtils.BookmarkDelete, id);
                await SQLiteUtils.Instance().DeleteBookmark(id);

                OkHttpUtils.Instance(token).Delete(url, async(call, response) =>
                {
                    var code = response.Code();
                    var body = await response.Body().StringAsync();
                    if (code == (int)System.Net.HttpStatusCode.OK)
                    {
                        bookmarksView.DeleteBookmarkSuccess(id);
                    }
                    else
                    {
                        try
                        {
                            var error = JsonConvert.DeserializeObject <ErrorMessage>(body);
                            bookmarksView.DeleteBookmarkFail(id, error.Message);
                        }
                        catch (Exception e)
                        {
                            bookmarksView.DeleteBookmarkFail(id, e.Message);
                        }
                    }
                }, (call, ex) =>
                {
                    bookmarksView.DeleteBookmarkFail(id, ex.Message);
                });
            }
            catch (Exception ex)
            {
                bookmarksView.DeleteBookmarkFail(id, ex.Message);
            }
        }
예제 #28
0
        public async Task GetServiceBlog(AccessToken token, string blogApp)
        {
            try
            {
                var result = await OkHttpUtils.Instance(token).GetAsyn(string.Format(ApiUtils.BlogApp, blogApp));

                if (result.IsError)
                {
                    blogView.GetServiceBlogFail(result.Message);
                }
                else
                {
                    var blog = JsonConvert.DeserializeObject <BlogModel>(result.Message);
                    blog.BlogApp = blogApp;
                    await SQLiteUtils.Instance().UpdateBlog(blog);

                    blogView.GetServiceBlogSuccess(blog);
                }
            }
            catch (Exception ex)
            {
                blogView.GetServiceBlogFail(ex.Message);
            }
        }
        public void DeleteAnswer(AccessToken token, int questionId, int answerId)
        {
            try
            {
                var url = string.Format(ApiUtils.QuestionsAnswerDelete, questionId, answerId);

                OkHttpUtils.Instance(token).Delete(url, async(call, response) =>
                {
                    var code = response.Code();
                    var body = await response.Body().StringAsync();
                    if (code == (int)System.Net.HttpStatusCode.OK)
                    {
                        answersView.DeleteAnswerSuccess(answerId);
                    }
                    else
                    {
                        try
                        {
                            var error = JsonConvert.DeserializeObject <ErrorMessage>(body);
                            answersView.DeleteAnswerFail(answerId, error.Message);
                        }
                        catch (Exception e)
                        {
                            answersView.DeleteAnswerFail(answerId, e.Message);
                        }
                    }
                }, (call, ex) =>
                {
                    answersView.DeleteAnswerFail(answerId, ex.Message);
                });
            }
            catch (Exception ex)
            {
                answersView.DeleteAnswerFail(answerId, ex.Message);
            }
        }
예제 #30
0
        public async Task GetServiceStatus(AccessToken token, int position, int pageIndex = 1)
        {
            try
            {
                string statusType = "all";
                switch (position)
                {
                case 0:
                    statusType = "all";
                    break;

                case 1:
                    statusType = "following";
                    break;

                case 2:
                    statusType = "my";
                    break;

                case 3:
                    statusType = "mycomment";
                    break;

                case 4:
                    statusType = "recentcomment";
                    break;

                case 5:
                    statusType = "mention";
                    break;

                case 6:
                    statusType = "comment";
                    break;

                default:
                    statusType = "all";
                    break;
                }
                var url    = string.Format(ApiUtils.Status, statusType, pageIndex, pageSize);
                var result = await OkHttpUtils.Instance(token).GetAsyn(url);

                if (result.IsError)
                {
                    statusView.GetServiceStatusFail(result.Message);
                    return;
                }
                else
                {
                    var statuses = JsonConvert.DeserializeObject <List <StatusModel> >(result.Message);
                    if (position == 0)
                    {
                        await SQLiteUtils.Instance().UpdateStatuses(statuses);
                    }
                    statusView.GetServiceStatusSuccess(statuses);
                }
            }
            catch (Exception ex)
            {
                statusView.GetServiceStatusFail(ex.Message);
            }
        }