Exemple #1
0
        private async Task <WxJsonResult> UpdateFileToWx(MpMediaArticleDto article, int mpid, string mediaID)
        {
            if (article == null)
            {
                return new WxJsonResult {
                           errcode = Senparc.Weixin.ReturnCode.POST的数据包为空, errmsg = "实体对象不存在", P2PData = null
                }
            }
            ;
            var account = _accountRepository.FirstOrDefault(m => m.Id == mpid);
            //var access_token = Senparc.Weixin.MP.Containers.AccessTokenContainer.TryGetAccessToken(account.AppId, account.AppSecret);
            var access_token = _accessTokenContainer.TryGetAccessTokenAsync(account.AppId, account.AppSecret).Result;
            var news         = new NewsModel()
            {
                title                 = article.Title,
                author                = article.Author,
                digest                = article.Description,
                content               = article.WxContent,
                content_source_url    = article.AUrl,
                show_cover_pic        = article.ShowPic,
                thumb_media_id        = article.PicMediaID,
                need_open_comment     = article.EnableComment,
                only_fans_can_comment = article.OnlyFansComment
            };
            WxJsonResult result = null;

            return(result = await MediaApi.UpdateForeverNewsAsync(access_token, mediaID, 0, news, Senparc.Weixin.Config.TIME_OUT));
        }
        private async Task <WxJsonResult> UpdateFileToWx(NewsModel news, int mpid, string mediaID, int index)
        {
            var account      = _accountRepository.FirstOrDefault(m => m.Id == mpid);
            var access_token = Senparc.Weixin.MP.Containers.AccessTokenContainer.TryGetAccessToken(account.AppId, account.AppSecret);

            return(await MediaApi.UpdateForeverNewsAsync(access_token, mediaID, index, news));
        }
Exemple #3
0
        public virtual async Task <string> UploadArticleAndGetMediaID(int mpid, NewsModel newsModel, bool isCreate = true, string mediaID = null)
        {
            var account = await _mpAccountAppService.Get(new Abp.Application.Services.Dto.EntityDto <int> {
                Id = mpid
            });

            var access_token = await _accessTokenContainer.TryGetAccessTokenAsync(account.AppId, account.AppSecret);

            try
            {
                if (isCreate)
                {
                    return((await MediaApi.UploadNewsAsync(access_token, Senparc.Weixin.Config.TIME_OUT, newsModel)).media_id);
                }
                else
                {
                    await MediaApi.UpdateForeverNewsAsync(access_token, mediaID, 0, newsModel, Senparc.Weixin.Config.TIME_OUT);

                    return(mediaID);
                }
            }
            catch
            {
                access_token = await _accessTokenContainer.TryGetAccessTokenAsync(account.AppId, account.AppSecret, true);

                try
                {
                    if (isCreate)
                    {
                        return((await MediaApi.UploadNewsAsync(access_token, Senparc.Weixin.Config.TIME_OUT, newsModel)).media_id);
                    }
                    else
                    {
                        await MediaApi.UpdateForeverNewsAsync(access_token, mediaID, 0, newsModel, Senparc.Weixin.Config.TIME_OUT);

                        return(mediaID);
                    }
                }
                catch (Exception e)
                {
                    throw new UserFriendlyException(e.Message);
                }
            }
        }
Exemple #4
0
 /// <summary>
 /// 修改永久图文素材
 /// </summary>
 /// <param name="access_token"></param>
 /// <param name="timeOut"></param>
 /// <param name="news"></param>
 /// <returns></returns>
 public async Task <WxJsonResult> UpdateForeverNewsAsync(string appid, string mediaId, NewsModel news, int timeOut = 10000)
 {
     return(await MediaApi.UpdateForeverNewsAsync(appid, mediaId, 0, news));
 }
Exemple #5
0
        public async Task <string> PushMaterialAsync(string accessTokenOrAppId, MaterialType materialType, int materialId)
        {
            string mediaId = null;

            if (materialType == MaterialType.Message)
            {
                var message = await _materialMessageRepository.GetAsync(materialId);

                var newsList = new List <NewsModel>();
                foreach (var item in message.Items)
                {
                    var news = new NewsModel
                    {
                        thumb_media_id        = item.ThumbMediaId,
                        author                = item.Author,
                        title                 = item.Title,
                        content_source_url    = item.ContentSourceUrl,
                        content               = item.Content,
                        digest                = item.Digest,
                        show_cover_pic        = item.ShowCoverPic ? "1" : "0",
                        thumb_url             = item.ThumbUrl,
                        need_open_comment     = item.CommentType == CommentType.Block ? 0 : 1,
                        only_fans_can_comment = item.CommentType == CommentType.OnlyFans ? 1 : 0
                    };
                    newsList.Add(news);
                }

                mediaId = message.MediaId;
                if (string.IsNullOrEmpty(mediaId))
                {
                    var result = await MediaApi.UploadNewsAsync(accessTokenOrAppId, 10000, newsList.ToArray());

                    mediaId = result.media_id;
                    await _materialMessageRepository.UpdateMediaIdAsync(materialId, mediaId);
                }
                else
                {
                    var index = 0;
                    foreach (var news in newsList)
                    {
                        await MediaApi.UpdateForeverNewsAsync(accessTokenOrAppId, message.MediaId, index ++, news);
                    }
                }

                // sync article url
                var media = await MediaApi.GetForeverNewsAsync(accessTokenOrAppId, mediaId);

                for (var i = 0; i < message.Items.Count; i++)
                {
                    var item = media.news_item[i];
                    await _materialArticleRepository.UpdateUrlAsync(message.Items[i].MaterialId, item.url);
                }
            }
            else if (materialType == MaterialType.Image)
            {
                var image = await _materialImageRepository.GetAsync(materialId);

                mediaId = image.MediaId;
                if (string.IsNullOrEmpty(mediaId))
                {
                    var filePath = _pathManager.ParsePath(image.Url);
                    if (FileUtils.IsFileExists(filePath))
                    {
                        var result = await MediaApi.UploadForeverMediaAsync(accessTokenOrAppId, filePath);

                        mediaId = result.media_id;
                        await _materialImageRepository.UpdateMediaIdAsync(materialId, mediaId);
                    }
                }
            }
            else if (materialType == MaterialType.Audio)
            {
                var audio = await _materialAudioRepository.GetAsync(materialId);

                mediaId = audio.MediaId;
                if (string.IsNullOrEmpty(mediaId))
                {
                    var filePath = _pathManager.ParsePath(audio.Url);
                    if (FileUtils.IsFileExists(filePath))
                    {
                        var result = await MediaApi.UploadForeverMediaAsync(accessTokenOrAppId, filePath);

                        mediaId = result.media_id;
                        await _materialAudioRepository.UpdateMediaIdAsync(materialId, mediaId);
                    }
                }
            }
            else if (materialType == MaterialType.Video)
            {
                var video = await _materialVideoRepository.GetAsync(materialId);

                mediaId = video.MediaId;
                if (string.IsNullOrEmpty(mediaId))
                {
                    var filePath = _pathManager.ParsePath(video.Url);
                    if (FileUtils.IsFileExists(filePath))
                    {
                        var result = await MediaApi.UploadForeverMediaAsync(accessTokenOrAppId, filePath);

                        mediaId = result.media_id;
                        await _materialVideoRepository.UpdateMediaIdAsync(materialId, mediaId);
                    }
                }
            }

            return(mediaId);
        }