protected override async Task <IEnumerable <UserProfile> > ExecuteAsync(QueryTemplateContext <GetUserProfileByUserIdQuery> context)
{
var queryParam = context.Parameter;
var table = RethinkDB.R
.Table(nameof(UserProfile));
var query = table
.Filter(x => x.GetField(nameof(UserProfile.OwnerId)).Eq(queryParam.UserId))
.Limit(1)
.Merge(profile => RethinkDB.R.HashMap(nameof(UserProfile.Owner), RethinkDB.R
.Table("ApplicationUser")
.Get(profile.GetField(nameof(UserProfile.OwnerId)))
.Pluck(nameof(User.FullName))));
try
{
return((await query.RunCursorAsync <UserProfile>(context.Connection)).ToList());
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
}
return(Enumerable.Empty <UserProfile>());
}
protected override async Task <IEnumerable <UserProfileStats> > ExecuteAsync(QueryTemplateContext <GetUserProfileStatsQuery> context)
{
var queryParam = context.Parameter;
var ideaTable = RethinkDB.R.Table(nameof(Idea));
var ideaCommentTable = RethinkDB.R.Table(nameof(IdeaComment));
var ideaLikeTable = RethinkDB.R.Table(nameof(IdeaLike));
var usersTable = RethinkDB.R.Table("ApplicationUser");
var ideaLikesQuery = ideaLikeTable.Filter(x => x[nameof(IdeaLike.OwnerId)].Eq(queryParam.UserId) && x[nameof(IdeaLike.IsLike)].Eq(true)).Count();
var ideaDisLikesQuery = ideaLikeTable.Filter(x => x[nameof(IdeaLike.OwnerId)].Eq(queryParam.UserId) && x[nameof(IdeaLike.IsLike)].Eq(false)).Count();
var ideaCommentsQuery = ideaCommentTable.Filter(x => x[nameof(IdeaComment.OwnerId)].Eq(queryParam.UserId)).Count();
var ideasQuery = ideaTable.Filter(x => x[nameof(Idea.OwnerId)].Eq(queryParam.UserId)).Filter(x => x.GetField(nameof(Idea.Status)).Eq(Status.Published.ToString())).Count();
var stats = await usersTable.Get(queryParam.UserId).Pluck("id")
.Merge(user => RethinkDB.R.HashMap(nameof(UserProfileStats.Likes), ideaLikesQuery))
.Merge(RethinkDB.R.HashMap(nameof(UserProfileStats.DisLikes), ideaDisLikesQuery))
.Merge(RethinkDB.R.HashMap(nameof(UserProfileStats.Comments), ideaCommentsQuery))
.Merge(RethinkDB.R.HashMap(nameof(UserProfileStats.Ideas), ideasQuery))
.RunAtomAsync <UserProfileStats>(context.Connection);
stats.UserId = queryParam.UserId;
return(new[] { stats });
}
protected override async Task <IEnumerable <Idea> > ExecuteAsync(QueryTemplateContext <FilterIdeaQuery> context)
{
var queryParam = context.Parameter;
var table = RethinkDB.R
.Table(nameof(Idea));
var query = table.Filter(x => x.HasFields(nameof(Idea.Title)));
if (!string.IsNullOrEmpty(queryParam.Keyword))
{
var keyword = $"(?i){queryParam.Keyword}";
query = query.Filter(x => x[nameof(Idea.Title)].Match(keyword)
.Or(x[nameof(Idea.Description)].Match(keyword)
.Or(x[nameof(Idea.FundingRequirement)].Match(keyword))));
}
if (!string.IsNullOrEmpty(queryParam.Status))
{
query = query.Filter(x => x[nameof(Idea.Status)].Eq(queryParam.Status));
}
if (!string.IsNullOrEmpty(queryParam.OwnerId))
{
query = query.Filter(x => x[nameof(Idea.OwnerId)].Eq(queryParam.OwnerId));
}
var exlcudedProps = new Collection <string>(queryParam.PropertiesToExclude);
var optimizedQuery = query.Without(exlcudedProps);
if (queryParam.Skip.HasValue)
{
optimizedQuery.Skip(queryParam.Skip);
}
if (queryParam.Take.HasValue)
{
optimizedQuery.Limit(queryParam.Take);
}
var finalQuery = optimizedQuery.Merge(idea => RethinkDB.R.HashMap(nameof(Idea.Owner), RethinkDB.R
.Table("ApplicationUser")
.Get(idea.GetField(nameof(Idea.OwnerId)))
.Pluck(nameof(User.FullName))));
var result = await finalQuery.RunCursorAsync <Idea>(context.Connection);
return(result.ToList());
}
protected override async Task <IEnumerable <IdeaComment> > ExecuteAsync(QueryTemplateContext <GetCommentByIdQuery> context)
{
var queryParam = context.Parameter;
var table = RethinkDB.R
.Table(nameof(IdeaComment));
var query = table.Get(queryParam.CommentId)
.Merge(idea => RethinkDB.R.HashMap(nameof(Idea.Owner), RethinkDB.R
.Table("ApplicationUser")
.Get(idea.GetField(nameof(IdeaComment.OwnerId)))
.Pluck(nameof(User.FullName))));
return(new[] { await query.RunAtomAsync <IdeaComment>(context.Connection) });
}
protected override async Task <IEnumerable <TeamMember> > ExecuteAsync(QueryTemplateContext <GetTeamMemberByUserIdQuery> context)
{
var queryParam = context.Parameter;
var table = RethinkDB.R
.Table(nameof(Team));
var query = table
.Filter(x => x[nameof(Team.IdeaId)].Eq(queryParam.IdeaId))
.ConcatMap(x => x.GetField(nameof(Team.Members)))
.Filter(y => y[nameof(TeamMember.MemberUserId)].Eq(queryParam.UserId));
var finalQuery = query.Merge(m => RethinkDB.R.HashMap(nameof(TeamMember.Member),
RethinkDB.R.Table("ApplicationUser")
.Get(m.GetField(nameof(TeamMember.MemberUserId))).Pluck(nameof(User.FullName))));
return((await finalQuery.RunCursorAsync <TeamMember>(context.Connection)).ToList());
}
protected override async Task <IEnumerable <IdeaComment> > ExecuteAsync(QueryTemplateContext <GetIdeaCommentsByIdeaIdQuery> context)
{
var queryParam = context.Parameter;
var table = RethinkDB.R
.Table(nameof(IdeaComment));
var query = table
.OrderBy()
.OptArg("index", RethinkDB.R.Desc(nameof(IdeaComment.CreatedOn)))
.Filter(comment => comment.GetField(nameof(IdeaComment.IdeaId)).Eq(queryParam.IdeaId));
var finalQuery = query.Merge(idea => RethinkDB.R.HashMap(nameof(Idea.Owner), RethinkDB.R
.Table("ApplicationUser")
.Get(idea.GetField(nameof(IdeaComment.OwnerId)))
.Pluck(nameof(User.FullName))));
return((await finalQuery.RunCursorAsync <IdeaComment>(context.Connection)).ToList());
}
protected override async Task <IEnumerable <IdeaLike> > ExecuteAsync(QueryTemplateContext <GetIdeaLikeByUserIdQuery> context)
{
var queryParam = context.Parameter;
var table = RethinkDB.R
.Table(nameof(IdeaLike));
var query = table
.Filter(x => x.GetField(nameof(IdeaLike.OwnerId)).Eq(queryParam.OwnerId).And(x.GetField(nameof(IdeaLike.IdeaId)).Eq(queryParam.IdeaId)))
.Limit(1)
.Merge(idea => RethinkDB.R.HashMap(nameof(IdeaLike.Owner), RethinkDB.R
.Table("ApplicationUser")
.Get(idea.GetField(nameof(IdeaLike.OwnerId)))
.Pluck(nameof(User.FullName))));
return(new[] {
(await query.RunCursorAsync <IdeaLike>(context.Connection)).FirstOrDefault()
});
}
protected override async Task <IEnumerable <Idea> > ExecuteAsync(QueryTemplateContext <GetIdeaByIdQuery> context)
{
var queryParam = context.Parameter;
var table = RethinkDB.R
.Table(nameof(Idea));
//var filter = RethinkDB.R.Js($@"(function(idea){{
// return idea.title.indexOf('{queryParam.Keyword}') >-1 ||idea.description.indexOf('{queryParam.Keyword}') > -1;
// }})");
var query = table
.Get(queryParam.IdeaId)
.Merge(idea => RethinkDB.R.HashMap(nameof(Idea.Owner), RethinkDB.R
.Table("ApplicationUser")
.Get(idea.GetField(nameof(Idea.OwnerId)))
.Pluck(nameof(User.FullName))));
return(new[] { await query.RunAtomAsync <Idea>(context.Connection) });
}
protected override async Task <IEnumerable <Team> > ExecuteAsync(QueryTemplateContext <GetTeamByIdeaIdQuery> context)
{
var queryParam = context.Parameter;
var teamTable = RethinkDB.R.Table(nameof(Team));
var userTable = RethinkDB.R.Table("ApplicationUser");
var filterTeams = teamTable.Filter(x => x[nameof(Team.IdeaId)].Eq(queryParam.IdeaId));
var query = filterTeams.Map(team =>
{
var teamMembers = team
.GetField(nameof(Team.Members))
.Map(member => {
return(member.Merge(RethinkDB.R.HashMap(nameof(TeamMember.Member),
userTable.Get(member.GetField(nameof(TeamMember.MemberUserId))).Pluck(nameof(User.FullName)))));
});
return(team.Merge(RethinkDB.R.HashMap(nameof(Team.Members), teamMembers)));
});
return((await query.RunCursorAsync <Team>(context.Connection)).ToList());
}
protected override async Task <IEnumerable <Idea> > ExecuteAsync(QueryTemplateContext <GetTopIdeaQuery> context)
{
var queryParam = context.Parameter;
var table = RethinkDB.R
.Table(nameof(Idea));
var query = table
.OrderBy()
.OptArg("index", RethinkDB.R.Desc(nameof(Idea.Comments)))
.Limit(queryParam.Count)
.Filter(x => x.GetField(nameof(Idea.Status)).Eq(Status.Published.ToString()))
.Filter(x => x.HasFields(nameof(Idea.Title)));
var finalQuery = query.Merge(idea => RethinkDB.R.HashMap(nameof(Idea.Owner), RethinkDB.R
.Table("ApplicationUser")
.Get(idea.GetField(nameof(Idea.OwnerId)))
.Pluck(nameof(User.FullName))));
var result = await finalQuery.RunCursorAsync <Idea>(context.Connection);
return(result.ToList());
}
protected abstract Task <IEnumerable <TEntity> > ExecuteAsync(QueryTemplateContext <TQueryParam> context);
protected override async Task <IEnumerable <IdeaCollaborationStats> > ExecuteAsync(QueryTemplateContext <GetIdeaCollaborationStatsQuery> context)
{
var queryParam = context.Parameter;
var ideaTable = RethinkDB.R.Table(nameof(Idea));
var ideaCommentTable = RethinkDB.R.Table(nameof(IdeaComment));
var ideaLikeTable = RethinkDB.R.Table(nameof(IdeaLike));
var ideaLikesQuery = ideaLikeTable.Filter(x => x[nameof(IdeaLike.IdeaId)].Eq(queryParam.IdeaId) && x[nameof(IdeaLike.IsLike)].Eq(true)).Count();
var ideaDisLikesQuery = ideaLikeTable.Filter(x => x[nameof(IdeaLike.IdeaId)].Eq(queryParam.IdeaId) && x[nameof(IdeaLike.IsLike)].Eq(false)).Count();
var ideaCommentsQuery = ideaCommentTable.Filter(x => x[nameof(IdeaLike.IdeaId)].Eq(queryParam.IdeaId)).Count();
var getStatsTask = ideaTable.Get(queryParam.IdeaId)
.Pluck(nameof(IdeaLike.IdeaId))
.Merge(idea => RethinkDB.R.HashMap(nameof(IdeaCollaborationStats.Likes), ideaLikesQuery))
.Merge(idea => RethinkDB.R.HashMap(nameof(IdeaCollaborationStats.DisLikes), ideaDisLikesQuery))
.Merge(idea => RethinkDB.R.HashMap(nameof(IdeaCollaborationStats.Comments), ideaCommentsQuery))
.RunAtomAsync <IdeaCollaborationStats>(context.Connection);
return(new[] { await getStatsTask });
}
