public async Task GetBySlug__Works_Properly()
{
// Arrange
var publishCmd = new PublishArticle
{
AuthorId = Guid.NewGuid().ToString(),
Body = Guid.NewGuid().ToString(),
Description = Guid.NewGuid().ToString(),
Title = "Some Title Here"
};
var articleView = await _service.Publish(publishCmd, null);
var query = new BySlug
{
Slug = articleView.Slug
};
// Act
var slug = await _service.GetBySlug(query, null);
// Assert
slug.HasResult.Should().BeTrue();
slug.View.Should().NotBeNull();
}
public override async Task <ArticleView> Publish(PublishArticle command, ServerCallContext context)
{
var article = _mapper.Map <Article>(command);
var entity = await _repository.PersistAsync(article);
var result = _mapper.Map <ArticleView>(entity);
return(result);
}
public async Task <int> PublishArticle(PublishArticle request)
{
//get the publisher from the session and then check if that publisher is able to publish that content or not
int publisherId = Convert.ToInt32(_httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier));
Article article = _dbContext.Articles.Where(x => x.Articleid == request.articleId && x.Submittedtoid == publisherId).FirstOrDefault();
article.Lastmodifieddate = DateTime.UtcNow;
article.Publisheddate = DateTime.UtcNow;
article.Publishedbyid = publisherId;
_dbContext.Entry(article).State = EntityState.Modified;
_dbContext.SaveChanges();
return(await System.Threading.Tasks.Task.FromResult(article.Articleid));
}
private static async Task <Option <ArticleView, Error> > PublishArticleOrErrorAsync(
PublishArticle article,
ArticleService.ArticleServiceClient client)
{
try
{
var view = await client.PublishAsync(article);
return(view.Some <ArticleView, Error>());
}
catch (RpcException)
{
return(Option.None <ArticleView, Error>(
Error.Critical("An unhandled exception occured while persisting the article.")));
}
}
public async Task <ActionResult> Create(PublishArticle model)
{
if (model == null)
{
ModelState.AddModelError("", "数据不允许为空!!");
}
if (string.IsNullOrEmpty(model.title))
{
ModelState.AddModelError("", "标题不允许为空!!");
}
//if (string.IsNullOrEmpty(model.outLink))
//{
// model.outLink = "http://www.instwin.com/act/upa/content.html";
//}
if (ModelState.IsValid)
{
var cate = new EasonRepository <ArticleCategory, long>();
var ct = await cate.GetAsync(model.categoryId);
Article art = new Article()
{
title = model.title,
contents = model.contents,
creationTime = DateTime.Now,
status = model.status,
categoryId = model.categoryId,
//channelId = model.channelId,
//typeId = model.typeId,
creatorName = User.Identity.Name,
imageUrl = model.imageUrl,
videoUrl = model.videoUrl,
mTitle = model.mTitle,
desc = model.desc,
categoryName = ct.title,
outLink = model.outLink,
creatorId = long.Parse((User.Identity as ClaimsIdentity).Claims.FirstOrDefault(m => m.Type == ClaimTypes.Sid).Value)
};
await repository.InsertAsync(art);
await repository.UnitOfWork.CommitAsync();
return(Jsonp(new { success = true }, JsonRequestBehavior.AllowGet));
}
return(View(model));
}
public async Task <ActionResult> Edit(PublishArticle model)
{
if (model == null)
{
ModelState.AddModelError("", "数据不允许为空!!");
}
if (string.IsNullOrEmpty(model.title))
{
ModelState.AddModelError("", "标题不允许为空!!");
}
var art = await repository.GetAsync(model.id);
var cate = new EasonRepository <ArticleCategory, long>();
var ct = await cate.GetAsync(model.categoryId);
if (art == null)
{
ModelState.AddModelError("", "该文章可能已经被删除!");
}
if (ModelState.IsValid)
{
art.title = model.title;
art.contents = model.contents;
art.creationTime = DateTime.Now;
art.status = model.status;
art.categoryId = model.categoryId;
// art.typeId = model.typeId;
art.creatorName = User.Identity.Name;
art.imageUrl = model.imageUrl;
art.videoUrl = model.videoUrl;
art.mTitle = model.mTitle;
art.desc = model.desc;
art.outLink = model.outLink;
art.categoryName = ct.title;
art.creatorId = long.Parse((User.Identity as ClaimsIdentity).Claims.FirstOrDefault(m => m.Type == ClaimTypes.Sid).Value);
await repository.UpdateAsync(art);
await repository.UnitOfWork.CommitAsync();
return(Jsonp(new { success = true }, JsonRequestBehavior.AllowGet));
}
return(View(model));
}
public async Task Publish_Works_Properly()
{
// Arrange
var publishCmd = new PublishArticle
{
AuthorId = Guid.NewGuid().ToString(),
Body = Guid.NewGuid().ToString(),
Description = Guid.NewGuid().ToString(),
Title = Guid.NewGuid().ToString()
};
// Act
var result = await _service.Publish(publishCmd, null);
// Assert
result.Should().NotBeNull();
}
public async Task <string> Publish(PublishArticle article)
{
var newsContent = await BuildNews(article);
var client = new HttpClient();
var token = await GetToken();
var url = WxApiUrlUploadNews !.Replace("$ACCESS_TOKEN", token);
var ret = await client.PostAsync <WxUploadNewsRes>(url,
new StringContent(newsContent, Encoding.UTF8, "application/json"));
if (string.IsNullOrWhiteSpace(ret.MediaId))
{
throw new Exception();
}
var msgId = await Send(ret.MediaId);
return(msgId ?? ret.MediaId);
}
public override async Task <AddResponce> Add(AddRequest request, ServerCallContext context)
{
var reply = new AddResponce();
var user = await _userService.GetUser(context.GetHttpContext());
if (user == null)
{
reply.Error = Error.NeedLogin;
return(reply);
}
if (!user.HasWritePermission())
{
reply.Error = Error.NoPermission;
return(reply);
}
var publishService = _publishServices[request.Type];
if (publishService == null)
{
reply.Error = Error.NoPermission;
return(reply);
}
if (!Guid.TryParse(request.ArticleId, out var articleId))
{
reply.Error = Error.NoSuchEntity;
return(reply);
}
var file = await _filesService.All()
.Where(f => f.Id == articleId && f.Type == (int)File.Types.FileType.Normal)
.FirstOrDefaultAsync();
if (file == null)
{
reply.Error = Error.NoSuchEntity;
return(reply);
}
var baseUrl = request.BaseUrl;
try
{
var article = new PublishArticle
{
Id = file.Id,
Title = file.Name,
BaseUrl = baseUrl,
Url = baseUrl + request.Url,
Group = request.Group
};
var regexp = new Regex(@"\$\{FILENAME=(.*?)\}");
var matches = regexp.Matches(request.Content);
var slices = new List <PublishArticleSlice>();
var cur = 0;
foreach (Match match in matches)
{
if (match.Index > cur)
{
slices.Add(new PublishArticleSlice
{
Type = PublishArticleSliceType.String,
Value = request.Content.Substring(cur, match.Index - cur)
});
}
slices.Add(new PublishArticleSlice
{
Type = PublishArticleSliceType.Image,
Value = match.Groups[1].Value
});
cur = match.Index + match.Value.Length;
}
if (cur < request.Content.Length)
{
slices.Add(new PublishArticleSlice
{
Type = PublishArticleSliceType.String,
Value = request.Content.Substring(cur, request.Content.Length - cur)
});
}
article.Slices = slices.ToArray();
var id = await publishService.Publish(article);
reply.Id = id;
}
catch
{
reply.Error = Error.InvalidArguments;
}
return(reply);
}
public Task <int> PublishArticle([FromBody] PublishArticle request)
{
var result = _articleService.PublishArticle(request: request).Result;
return(Task.FromResult(result));
}
