internal TwitterFeedService(IUserReader userReader, ITweetReader tweetReader, ITwitterRepository repo, IView <IEnumerable <UserFeed> > view)
{
_repo = repo;
_userReader = userReader;
_tweetReader = tweetReader;
_view = view;
}
public UsersController(IMediator mediator, IUserReader reader, IMapper mapper, IUserResolver userResolver)
{
_mediator = mediator;
_reader = reader;
_mapper = mapper;
_userResolver = userResolver;
}
public async Task <CommentReadView?> FindById(int id, User?user = null)
{
var comments = await Connection.QueryAsync <CommentRecord>(
@"WITH RECURSIVE commenttree AS (
SELECT r.* FROM comment r WHERE id = @Id AND was_deleted = FALSE
UNION ALL
SELECT c.* FROM comment c
INNER JOIN commenttree ct ON ct.id = c.parent_id
WHERE c.was_deleted = FALSE
) SELECT * FROM commenttree
ORDER BY parent_id, creation_date ASC;",
new { Id = id }
);
IUserReader userReader = GetReader <IUserReader>();
IVoteReader voteReader = GetReader <IVoteReader>();
List <CommentReadView> views = new List <CommentReadView>();
foreach (CommentRecord comment in comments)
{
CommentReadView view = Map(comment);
view.User = (await userReader.FindById(comment.UserId)) !;
if (user != null)
{
view.Vote = await voteReader.FindByCommentAndUser(comment.Id, user.Id);
}
views.Add(view);
}
// We're assuming there will always be one top level comment.
return(BuildCommentTree(views)[0]);
}
public ConnectionsController(
IUserReader userReader,
IUserRepository userRepository)
{
UserReader = userReader;
UserRepository = userRepository;
}
public async Task <IEnumerable <CommentReadView> > FindByPost(int postId, User?user = null)
{
var comments = (await Connection.QueryAsync <CommentRecord>(
@"WITH RECURSIVE commenttree AS (
SELECT r.* FROM comment r WHERE post_id = @PostId AND parent_id = 0 AND was_deleted = FALSE
UNION ALL
SELECT c.* FROM comment c
INNER JOIN commenttree ct ON ct.id = c.parent_id
WHERE c.was_deleted = FALSE
) SELECT * FROM commenttree
ORDER BY parent_id, creation_date DESC;",
new { PostId = postId }
));
IUserReader userReader = GetReader <IUserReader>();
IVoteReader voteReader = GetReader <IVoteReader>();
List <CommentReadView> views = new List <CommentReadView>();
foreach (CommentRecord comment in comments)
{
CommentReadView view = Map(comment);
view.User = (await userReader.FindById(comment.UserId)) !;
if (user != null)
{
view.Vote = await voteReader.FindByCommentAndUser(comment.Id, user.Id);
}
views.Add(view);
}
return(BuildCommentTree(views));
}
private void fetchOldFriendsFromFile()
{
using (IUserReader fileStream = ReaderFactory.GetUserReader(r_FriendFacadeBase.FriendsDataPath))
{
foreach (OldFriend oldFriend in fileStream)
{
if (r_FriendFacadeBase.SearchInFriendsListById(oldFriend.Id) == false)
{
r_OldFriends.Add(oldFriend);
}
}
}
/*
* using (IUserReader fileStream =
* ReaderFactory.GetUserReader(r_FriendFacadeBase.FriendsDataPath))
* {
* OldFriend oldFriend;
*
* while ((oldFriend = fileStream.ReadOldFriend()) != null)
* {
* if (r_FriendFacadeBase.SearchInFriendsListById(oldFriend.Id) == false)
* {
* r_OldFriends.Add(oldFriend);
* }
* }
* }
*/
}
public UserController(IConfiguration config, IDbConnector connector, IPermissionReader permissionReader, IUserReader userReader)
{
_config = config;
_connector = connector;
_permissionReader = permissionReader;
_userReader = userReader;
}
public async Task <PostReadView?> FindById(int id, User?user = null)
{
var post = await Connection.QueryFirstOrDefaultAsync <PostRecord>(
@"SELECT * FROM post
WHERE was_deleted = FALSE
ORDER BY post.creation_date DESC
LIMIT @Limit
OFFSET @Offset",
new {
Id = id
}
);
//Get total count
int totalCount = await Connection.ExecuteScalarAsync <int>(
"SELECT COUNT(*) FROM post;"
);
IUserReader userReader = GetReader <IUserReader>();
ISpaceReader spaceReader = GetReader <ISpaceReader>();
PostReadView view = Map(post);
view.User = (await userReader.FindById(post.UserId)) !;
view.Space = (await spaceReader.FindById(post.SpaceId)) !;
return(view);
}
/// <summary>
/// I use Poor Man's DI, to illustrate that the sources of Users/Followers and Tweet could come from other sources, like an XML file etc.
/// </summary>
internal TwitterFeedService(IUserReader userReader, ITweetReader tweetReader, IView <IEnumerable <UserFeed> > view)
{
_userFeeds = new Dictionary <User, UserFeed>();
_userReader = userReader;
_tweetReader = tweetReader;
_view = view;
}
public HomeController(IMessageRepository messageRepository,
IUserReader userReader,
IMapper<Message, MessageViewModel> messageMapper,
IMapper<UserMessage, MessageViewModel> userMessageMapper)
{
this.messageRepository = messageRepository;
this.userReader = userReader;
this.messageMapper = messageMapper;
this.userMessageMapper = userMessageMapper;
}
public bool SearchInFriendsFile(User i_FriendId)
{
bool doesExistInFile = false;
using (IUserReader streamReaderAdapter = ReaderFactory.GetUserReader(FriendsDataPath))
{
doesExistInFile = streamReaderAdapter.SearchFriend(i_FriendId);
}
return(doesExistInFile);
}
public HomeController(IMessageRepository messageRepository,
IUserReader userReader,
IMapper <Message, MessageViewModel> messageMapper,
IMapper <UserMessage, MessageViewModel> userMessageMapper,
IMapper <User, UserViewModel> userViewModelMapper)
{
this.messageRepository = messageRepository;
this.userReader = userReader;
this.messageMapper = messageMapper;
this.userMessageMapper = userMessageMapper;
this.userViewModelMapper = userViewModelMapper;
}
public ConsoleApplication(
IUserReader userReader,
IUserWriter userWriter)
{
_userReader = userReader;
_userWriter = userWriter;
_userReader.QueryAsync(user => true).GetAwaiter().GetResult()
.Select(user => user.EmailAddress)
.ToList()
.ForEach(emailAddress =>
_emailAddresses.Value.Add(emailAddress)
);
}
public async Task <IEnumerable <SpaceReadView> > FindDefault()
{
var defaults = await Connection.QueryAsync <SpaceRecord>(
@"SELECT * FROM space WHERE is_default = TRUE"
);
var views = defaults.Select(s => Map(s)).ToArray();
IUserReader userReader = GetReader <IUserReader>();
for (int i = 0; i < views.Length; i++)
{
views[i].User = (await userReader.FindById(defaults.ElementAt(i).UserId)) !;
}
return(views);
}
public async Task <PagedResultSet <CommentReadView> > FindByUser(string username, PaginationInfo paging, User?user = null)
{
var comments = await Connection.QueryAsync <CommentRecord>(
@"SELECT comment.* FROM comment
LEFT JOIN ""user"" ON comment.user_id = ""user"".id
WHERE ""user"".username = @Username AND was_deleted = FALSE
ORDER BY creation_date DESC
LIMIT @Limit
OFFSET @Offset ",
new {
Username = username,
Limit = paging.PageNumber,
Offset = paging.Offset
}
);
//Get total count
int totalCount = await Connection.ExecuteScalarAsync <int>(
@"SELECT COUNT(*) FROM comment
LEFT JOIN ""user"" ON comment.user_id = ""user"".id
WHERE ""user"".username = @Username AND was_deleted = FALSE",
new { Username = username }
);
IUserReader userReader = GetReader <IUserReader>();
IVoteReader voteReader = GetReader <IVoteReader>();
List <CommentReadView> views = new List <CommentReadView>();
foreach (CommentRecord comment in comments)
{
CommentReadView view = Map(comment);
view.User = (await userReader.FindById(comment.UserId)) !;
if (user != null)
{
view.Vote = await voteReader.FindByCommentAndUser(comment.Id, user.Id);
}
views.Add(view);
}
return(new PagedResultSet <CommentReadView>(views, paging));
}
public async Task <PagedResultSet <PostReadView> > FindByUser(string username, PaginationInfo paging, User?user = null)
{
var posts = await Connection.QueryAsync <PostRecord>(
@"SELECT post.* FROM post
LEFT JOIN ""user"" u1 ON u1.id = post.user_id
WHERE u1.username = @Username AND post.was_deleted = FALSE
ORDER BY post.creation_date DESC
LIMIT @Limit
OFFSET @Offset",
new {
Username = username,
Limit = paging.PageSize,
Offset = paging.Offset
}
);
//Get total count
int totalCount = await Connection.ExecuteScalarAsync <int>(
@"SELECT COUNT(*) FROM post
LEFT JOIN ""user"" ON post.user_id = ""user"".id
WHERE ""user"".username = @Username AND post.was_deleted = FALSE",
new { Username = username }
);
IUserReader userReader = GetReader <IUserReader>();
ISpaceReader spaceReader = GetReader <ISpaceReader>();
List <PostReadView> views = new List <PostReadView>();
foreach (PostRecord post in posts)
{
PostReadView view = Map(post);
view.User = (await userReader.FindById(post.UserId)) !;
view.Space = (await spaceReader.FindById(post.SpaceId)) !;
views.Add(view);
}
return(new PagedResultSet <PostReadView>(views, new PaginationInfo(paging.PageNumber, paging.PageSize, totalCount)));
}
public async Task <IEnumerable <SpaceReadView> > FindSubscribed(User user)
{
var subscribes = await Connection.QueryAsync <SpaceRecord>(
@"SELECT * FROM space
LEFT JOIN ""user"" ON space.user_id = ""user"".id
LEFT JOIN subscription ON space.id = subscription.space_id
WHERE subscription.user_id = @Id",
user
);
var views = subscribes.Select(s => Map(s)).ToArray();
IUserReader userReader = GetReader <IUserReader>();
for (int i = 0; i < views.Length; i++)
{
views[i].User = (await userReader.FindById(subscribes.ElementAt(i).UserId)) !;
}
return(views);
}
public async Task <SpaceReadView?> FindByName(string name)
{
var space = (await Connection.QueryFirstOrDefaultAsync <SpaceRecord>(
@"SELECT * FROM space WHERE LOWER(space.name) = LOWER(@Name)",
new { Name = name }
));
if (space == null)
{
return(null);
}
SpaceReadView view = Map(space);
IUserReader userReader = GetReader <IUserReader>();
view.User = (await userReader.FindById(space.UserId)) !;
return(view);
}
public async Task <SpaceReadView?> FindById(int id)
{
var space = (await Connection.QueryFirstOrDefaultAsync <SpaceRecord>(
@"SELECT * FROM space WHERE space.id = @Id",
new { Id = id }
));
if (space == null)
{
return(null);
}
SpaceReadView view = Map(space);
IUserReader userReader = GetReader <IUserReader>();
view.User = (await userReader.FindById(space.UserId)) !;
return(view);
}
public async Task <PagedResultSet <PostReadView> > FindByNew(PaginationInfo paging, User?user = null)
{
var posts = await Connection.QueryAsync <PostRecord>(
@"SELECT * FROM post
WHERE was_deleted = FALSE
ORDER BY post.creation_date DESC
LIMIT @Limit
OFFSET @Offset",
new {
Limit = paging.PageSize,
Offset = paging.Offset
}
);
//Get total count
int totalCount = await Connection.ExecuteScalarAsync <int>(
"SELECT COUNT(*) FROM post;"
);
IUserReader userReader = GetReader <IUserReader>();
ISpaceReader spaceReader = GetReader <ISpaceReader>();
List <PostReadView> views = new List <PostReadView>();
foreach (PostRecord post in posts)
{
PostReadView view = Map(post);
view.User = (await userReader.FindById(post.UserId)) !;
view.Space = (await spaceReader.FindById(post.SpaceId)) !;
views.Add(view);
}
return(new PagedResultSet <PostReadView>(views, new PaginationInfo(paging.PageNumber, paging.PageSize, totalCount)));
}
public UserProfileQueryHandler(IPrincipalProvider principalProvider, IUserReader userReader)
{
_principalProvider = principalProvider;
_userReader = userReader;
}
public FindUserByUsernameQueryHandler(IUserReader userReader)
{
this.userReader = userReader;
}
public FindAdminsQueryHandler(IUserReader userReader)
{
this.userReader = userReader;
}
public UserWriter()
{
this.dbr = new DataBaseReader();
this.userReader = new UserReader();
}
public UserByIdQueryHandler(IUserReader userReader)
{
_userReader = userReader;
}
public UserValidator(IRouterInput routerInput, IUserReader userReader)
{
_routerInput = routerInput ?? throw new ArgumentNullException(nameof(routerInput));
_userReader = userReader ?? throw new ArgumentNullException(nameof(userReader));
}
public override void SetUp()
{
base.SetUp();
messageRepository = fixture.Freeze<IMessageRepository>();
userReader = fixture.Freeze<IUserReader>();
messageMapper = fixture.Freeze<IMapper<Message, MessageViewModel>>();
userMessageMapper = fixture.Freeze<IMapper<UserMessage, MessageViewModel>>();
userViewModelMapper = fixture.Freeze<IMapper<User, UserViewModel>>();
sut = fixture.Create<HomeController>();
}
public UserUpdater(IHttpClientFactory httpClientFactory)
{
_httpClientFactory = httpClientFactory;
_httpClient = httpClientFactory.CreateClient("bugTrackerClient");
UserReader = new UserReader.UserReader(_httpClientFactory);
}
public void Setup()
{
var loggerFactory = TestHelper.CreateLogger( );
_reader = new UserReader(new TestConnectionFactory( ), loggerFactory.CreateLogger <UserReader> ( ));
}
public GetUserByAuth0IdHandler(IUserReader userReader)
{
this.userReader = userReader;
}
public FindModeratorsBySpaceQueryHandler(IUserReader roleReader)
{
this.userReader = roleReader;
}
public GetUserByEmailQueryHandler(IUserReader userRepository)
{
this.userRepository = userRepository;
}
