Пример #1
0
        public async Task <List <Shout> > GetAsync(ShoutsFilter shoutsFilter, int lastId = 0, short limit = 10)
        {
            if (lastId < 0 || limit < 1)
            {
                throw new ArgumentOutOfRangeException();
            }

            return(await this._shoutStore.GetAsync(shoutsFilter, lastId, limit));
        }
Пример #2
0
        public async Task <List <Shout> > GetAsync(ShoutsFilter shoutsFilter, int lastId = 0, short limit = 10)
        {
            string query         = DapperHelperQueries.GetShoutQueryWithoutWhere();
            string hashtagClause = "";

            if (shoutsFilter?.Hashtags.Length > 0)
            {
                throw new NotImplementedException();

                StringBuilder stringBuilder = new StringBuilder();

                stringBuilder.Append(@"IN(
                                            SELECT ShoutId
                                            FROM HashtagShout
                                                INNER JOIN Hashtag
                                                ON HashtagShout.HashtagId = Hashtag.Id
                                            WHERE Hashtag.Content IN(
                ");

                for (int i = 0; i < shoutsFilter.Hashtags.Length; ++i)
                {
                    // TODO: Turn this into a parameterized query.
                    stringBuilder.Append(shoutsFilter.Hashtags);

                    if (i < shoutsFilter.Hashtags.Length - 1)
                    {
                        stringBuilder.Append(", ");
                    }
                }

                stringBuilder.Append(") ) ");
                hashtagClause = stringBuilder.ToString();
            }

            query += $"WHERE {DapperHelperQueries.PaginatedQuery( "Shout", lastId )} ";

            if (shoutsFilter.FilteredBy == FilterType.MostComments)
            {
                query += $@"AND Id IN(
                                SELECT ShoutId
                                FROM Comment
                                {( shoutsFilter.Hashtags.Length > 0 ? $"WHERE ShoutId {hashtagClause}" : "" )}
                                GROUP BY ShoutId
                                ORDER BY COUNT(ShoutId) DESC
                                LIMIT {limit}
                            )
                         ";
            }
            else
            {
                query += $"{( shoutsFilter.Hashtags.Length > 0 ? $"AND Id {hashtagClause}" : "" )}";

                query += " ORDER BY " + shoutsFilter.FilteredBy.Switch(new Dictionary <FilterType, Func <string> >()
                {
                    { FilterType.Top, () => "Shout.LikesCount, Shout.CreateDate DESC" },
                    { FilterType.Last, () => "Shout.CreateDate DESC" }
                },
                                                                       () => "ORDER BY Shout.LikesCount DESC"
                                                                       );

                query += $" LIMIT {limit}";
            }

            await base._dBContext.OpenDBConnectionAsync();

            using (base._dBContext.DbConnection)
            {
                return((List <Shout>) await base._dBContext.DbConnection.QueryAsync <Shout>(query));
            }
        }