public async Task <IHttpActionResult> GetListOfRelated(string id,
NormalPointIdentityType idType = NormalPointIdentityType.Id)
{
var point = await _dbContext.NormalPoints
.SingleOrDefaultAsync(p => idType == NormalPointIdentityType.IdCode?p.IdCode == id : p.Id == id);
if (point == null || (point.Type != NormalPointType.Game && point.Type != NormalPointType.Hardware))
{
return(NotFound());
}
return(Ok(point.DeveloperPoints
.Concat(point.PublisherPoints)
.Concat(point.SeriesPoints)
.Concat(point.GenrePoints)
.Concat(point.TagPoints)
.Distinct()
.Select(p => new NormalPointGetListOfRelatedResponseDto
{
Id = p.Id,
IdCode = p.IdCode,
Name = GetPreferredName(p)
}).ToList()));
}
public async Task <IHttpActionResult> GetListOfRelatedGames(string id, PointRelationship relationship,
bool stats = false, NormalPointIdentityType idType = NormalPointIdentityType.Id, int skip = 0, int take = 9)
{
if (take > 50)
{
take = 50;
}
var point = await _dbContext.NormalPoints
.SingleOrDefaultAsync(p => idType == NormalPointIdentityType.IdCode?p.IdCode == id : p.Id == id);
if (point == null || (point.Type != NormalPointType.Manufacturer && point.Type != NormalPointType.Genre))
{
return(NotFound());
}
var queryBase = _dbContext.NormalPoints.Where(p => p.Id == point.Id);
IQueryable <Models.NormalPoint> queryNext;
switch (relationship)
{
case PointRelationship.Developer:
queryNext = queryBase.SelectMany(p => p.DeveloperForPoints);
break;
case PointRelationship.Publisher:
queryNext = queryBase.SelectMany(p => p.PublisherForPoints);
break;
case PointRelationship.Series:
queryNext = queryBase.SelectMany(p => p.SeriesForPoints);
break;
case PointRelationship.Genre:
queryNext = queryBase.SelectMany(p => p.GenreForPoints);
break;
case PointRelationship.Tag:
queryNext = queryBase.SelectMany(p => p.TagForPoints);
break;
default:
throw new ArgumentOutOfRangeException(nameof(relationship), relationship, null);
}
var points = await queryNext.OrderByDescending(p => p.ReleaseDate)
.Skip(() => skip).Take(() => take).ToListAsync();
var userId = User.Identity.GetUserId();
return(Ok(points.Select(p =>
{
var dto = new NormalPointDto(p)
{
ReleaseDate = p.ReleaseDate
};
if (stats)
{
dto.SubscriberCount = _dbContext.NormalPoints.Where(np => np.Id == p.Id)
.Select(np => np.Subscribers.Count)
.Single();
dto.ArticleCount = _dbContext.NormalPoints.Where(np => np.Id == p.Id)
.Select(np => np.Articles.Count)
.Single();
dto.Subscribed = _dbContext.NormalPoints.Where(np => np.Id == p.Id)
.SelectMany(np => np.Subscribers)
.Select(u => u.Id)
.Contains(userId);
}
return dto;
})));
}
public async Task <IHttpActionResult> GetListByNormalPointId(string normalPointId,
NormalPointIdentityType idType, string articleTypeFilter = null, int beforeSn = int.MaxValue,
int take = 30)
{
if (take > 50)
{
take = 50;
}
var articleQuery = _dbContext.Articles.AsNoTracking().Where(a => a.SequenceNumber < beforeSn &&
a.Archived == ArchivedState.None &&
a.Rejected == false);
switch (idType)
{
case NormalPointIdentityType.Id:
articleQuery = articleQuery.Where(a => a.AttachedPoints.Select(p => p.Id).Contains(normalPointId));
break;
case NormalPointIdentityType.IdCode:
articleQuery =
articleQuery.Where(a => a.AttachedPoints.Select(p => p.IdCode).Contains(normalPointId));
break;
default:
throw new ArgumentOutOfRangeException(nameof(idType), idType, null);
}
if (articleTypeFilter != null)
{
var types = articleTypeFilter.Split(',').Select(s => s.Trim().ToEnum <ArticleType>()).ToList();
articleQuery =
articleQuery.Where(PredicateBuilder.Contains <Models.Article, ArticleType>(types, a => a.Type));
}
var articleEntries = await articleQuery.OrderByDescending(a => a.SequenceNumber).Take(() => take).Select(
a => new
{
article = a,
likeCount = a.Likes.Count,
commentCount = a.Comments.Count,
type = a.Type,
author = a.Principal.User,
voteForPoint = a.VoteForPoint
}).ToListAsync();
return(Ok(articleEntries.Select(entry =>
{
var articleDto = new ArticleDto(entry.article, true, 256, true)
{
LikeCount = entry.likeCount,
CommentCount = entry.commentCount,
TypeName = entry.type.ToString(),
Author = new UserDto(entry.author),
VoteForPoint = entry.voteForPoint == null ? null : new NormalPointDto(entry.voteForPoint, true)
};
if (string.IsNullOrWhiteSpace(entry.article.ThumbnailImage))
{
articleDto.ThumbnailImage = entry.voteForPoint?.BackgroundImage;
}
if (entry.type != ArticleType.简评)
{
articleDto.TruncateContent(128);
}
return articleDto;
})));
}
public async Task <IHttpActionResult> GetOneById(string id, bool stats = false, bool votes = false,
bool subscribed = false, bool related = false, bool coverDescription = false,
bool more = false, NormalPointIdentityType idType = NormalPointIdentityType.Id)
{
var point = await _dbContext.NormalPoints
.SingleOrDefaultAsync(p => idType == NormalPointIdentityType.IdCode?p.IdCode == id : p.Id == id);
if (point == null)
{
return(NotFound());
}
var pointDto = new NormalPointDto(point);
if (stats)
{
var statsResult = await _dbContext.NormalPoints
.Where(p => p.Id == point.Id)
.Select(p => new { articleCount = p.Articles.Count, subscriberCount = p.Subscribers.Count })
.SingleAsync();
pointDto.ArticleCount = statsResult.articleCount;
pointDto.SubscriberCount = statsResult.subscriberCount;
}
if (subscribed)
{
var userId = User.Identity.GetUserId();
pointDto.Subscribed = await _dbContext.Users.Where(u => u.Id == userId)
.SelectMany(u => u.SubscribedPoints)
.Select(p => p.Id)
.ContainsAsync(point.Id);
}
if (votes)
{
var votesResult = await _dbContext.NormalPoints
.Where(p => p.Id == point.Id)
.Select(
p => new
{
level1 = p.VoteByArticles.Count(a => a.Vote == 1),
level2 = p.VoteByArticles.Count(a => a.Vote == 2),
level3 = p.VoteByArticles.Count(a => a.Vote == 3),
level4 = p.VoteByArticles.Count(a => a.Vote == 4),
level5 = p.VoteByArticles.Count(a => a.Vote == 5)
})
.SingleAsync();
pointDto.VoteStats = new Dictionary <int, int>
{
[1] = votesResult.level1,
[2] = votesResult.level2,
[3] = votesResult.level3,
[4] = votesResult.level4,
[5] = votesResult.level5
};
}
if (related)
{
switch (point.Type)
{
case NormalPointType.Game:
case NormalPointType.Hardware:
pointDto.SteamAppId = point.SteamAppId;
pointDto.DisplayAliases = point.DisplayAliases;
pointDto.ReleaseDate = point.ReleaseDate;
pointDto.DeveloperPoints =
point.DeveloperPoints.Select(p => new NormalPointDto(p, true)).ToList();
pointDto.PublisherPoints =
point.PublisherPoints.Select(p => new NormalPointDto(p, true)).ToList();
pointDto.SeriesPoints = point.SeriesPoints.Select(p => new NormalPointDto(p, true)).ToList();
pointDto.GenrePoints = point.GenrePoints.Select(p => new NormalPointDto(p, true)).ToList();
pointDto.TagPoints = point.TagPoints.Select(p => new NormalPointDto(p, true)).ToList();
pointDto.MajorPlatformPoints =
point.MajorPlatformPoints.Select(p => new NormalPointDto(p, true)).ToList();
pointDto.MinorPlatformPoints =
point.MinorPlatformPoints.Select(p => new NormalPointDto(p, true)).ToList();
break;
case NormalPointType.Manufacturer:
pointDto.GameCountAsDeveloper = point.DeveloperForPoints.Count;
pointDto.GameCountAsPublisher = point.PublisherForPoints.Count;
break;
case NormalPointType.Genre:
pointDto.GameCountAsGenre = point.GenreForPoints.Count;
pointDto.GameCountAsSeries = point.SeriesForPoints.Count;
pointDto.GameCountAsTag = point.TagForPoints.Count;
break;
}
}
if (coverDescription)
{
if (point.Type == NormalPointType.Game || point.Type == NormalPointType.Hardware)
{
pointDto.CoverImage = point.CoverImage;
}
pointDto.Description = point.Description;
}
if (more)
{
pointDto.ChineseAliases = point.ChineseAliases;
pointDto.EnglishAliases = point.EnglishAliases;
pointDto.NameInSteamStore = string.Join("; ", point.SteamStoreNames.Select(n => n.Name));
}
return(Ok(pointDto));
}
