protected override async Task <UserLogin> HandleInput(UserRegisterParams input)
{
using (var connection = database.GetConnection()) {
using (var transaction = connection.BeginTransaction()) {
IUserRepo userRepo = database.GetRepo <IUserRepo>(connection);
ISpaceRepo spaceRepo = database.GetRepo <ISpaceRepo>(connection);
ISubscriptionRepo subRepo = database.GetRepo <ISubscriptionRepo>(connection);
// Check that the email is free first.
if (!String.IsNullOrWhiteSpace(input.Email))
{
User?emailInUse = await userRepo.FindByEmail(input.Email);
if (emailInUse != null)
{
throw new CollisionException("Email is already in use");
}
}
User?usernameInUse = await userRepo.FindByUsername(input.Username);
if (usernameInUse != null)
{
throw new CollisionException("Username is unavailable");
}
User user = new User()
{
Username = input.Username,
PasswordHash = passwordHasher.Hash(input.Password),
Email = StringUtils.NullifyWhiteSpace(input.Email),
JoinedDate = System.DateTime.UtcNow
};
await userRepo.Add(user);
// Subscribe the user to the default spaces.
IEnumerable <Space> defaultSpaces = await spaceRepo.FindDefault();
IEnumerable <Subscription> defaultSubscriptions = defaultSpaces.Select(space => new Subscription()
{
User = user, Space = space
});
foreach (Subscription s in defaultSubscriptions)
{
await subRepo.Add(s);
s.Space.SubscriptionCount++;
await spaceRepo.Update(s.Space);
}
UserView userView = userMapper.Map(user);
string authToken = tokenHandler.IssueToken(user);
transaction.Commit();
return(new UserLogin(userView, authToken));
}
}
}
protected override async Task HandleInput(SubscriptionDeleteParams input)
{
using (var conenction = database.GetConnection()) {
ISpaceRepo spaceRepo = database.GetRepo <ISpaceRepo>(conenction);
ISubscriptionRepo subRepo = database.GetRepo <ISubscriptionRepo>(conenction);
//Pull in the space first
Space?space = await spaceRepo.FindByName(input.Space);
if (space == null)
{
throw new InvalidOperationException($"No space with name {input.Space} exists.");
}
//Try to pull in the subscription
Subscription?sub = await subRepo.FindByUserAndSpace(input.User.Username, input.Space);
if (sub == null)
{
throw new InvalidOperationException("Subscription does not exist");
}
await subRepo.Delete(sub);
space.SubscriptionCount--;
await spaceRepo.Update(space);
}
}
public RoleService(IEventBus eventBus, IRoleFactory roleFactory, IUserRepo userRepo, IRoleRepo roleRepo, ISpaceRepo spaceRepo)
{
this.eventBus = eventBus;
this.roleFactory = roleFactory;
this.userRepo = userRepo;
this.roleRepo = roleRepo;
this.spaceRepo = spaceRepo;
}
protected override async Task <SpaceView?> HandleInput(FindByValueParams <string> input)
{
using (var connection = database.GetConnection()) {
ISpaceRepo spaceRepo = database.GetRepo <ISpaceRepo>(connection);
Space?s = await spaceRepo.FindByName(input.Value);
return(s != null?spaceMapper.Map(s) : null);
}
}
protected override async Task <PagedResultSet <SpaceView> > HandleInput(FindParams input)
{
using (var connection = database.GetConnection()) {
ISpaceRepo spaceRepo = database.GetRepo <ISpaceRepo>(connection);
PagedResultSet <Space> spaces = await spaceRepo.Find(input.Pagination?.PageNumber ?? 0, input.Pagination?.PageSize ?? Post.PageSize);
return(new PagedResultSet <SpaceView>(spaces.Select(s => mapper.Map(s)), spaces.Pagination));
}
}
protected override async Task <IEnumerable <SpaceView> > HandleInput(FindParams input)
{
using (var connection = database.GetConnection()) {
ISpaceRepo spaceRepo = database.GetRepo <ISpaceRepo>(connection);
IEnumerable <Space> spaces = await spaceRepo.FindDefault();
return(spaces.Select(s => spaceMapper.Map(s)));
}
}
protected override async Task <PostView?> HandleInput(PostCreateParams input)
{
using (var connection = database.GetConnection()) {
ISpaceRepo spaceRepo = database.GetRepo <ISpaceRepo>(connection);
IPostRepo postRepo = database.GetRepo <IPostRepo>(connection);
IVoteRepo voteRepo = database.GetRepo <IVoteRepo>(connection);
Space?space = await spaceRepo.FindByName(input.Space);
if (space == null)
{
throw new InvalidOperationException($"No space with name ${input.Space} found.");
}
using (var transaction = connection.BeginTransaction()) {
Post post = new Post()
{
Type = input.Type,
Title = input.Title,
Body = input.Body,
User = input.User,
CreationDate = DateTime.UtcNow,
Space = space
};
if (post.Type == PostType.Link && !System.Text.RegularExpressions.Regex.IsMatch(post.Body, Regex.UrlProtocol))
{
post.Body = $"http://{post.Body}";
}
// Not liking these count caches. Makes no sense?
post.Upvotes++;
await postRepo.Add(post);
Vote upvote = new Vote()
{
User = input.User,
ResourceId = post.Id,
ResourceType = VoteResourceType.Post,
Direction = VoteDirection.Up
};
await voteRepo.Add(upvote);
post.Vote = upvote;
transaction.Commit();
return(postMapper.Map(post));
}
}
}
protected override async Task <SubscriptionView> HandleInput(SubscriptionCreateParams input)
{
using (var connection = database.GetConnection()) {
ISpaceRepo spaceRepo = database.GetRepo <ISpaceRepo>(connection);
ISubscriptionRepo subRepo = database.GetRepo <ISubscriptionRepo>(connection);
//Check to see if the Space exists first
Space?space = await spaceRepo.FindByName(input.Space);
if (space == null)
{
throw new InvalidOperationException($"No space with name {input.Space} exists.");
}
//Ensure no sub for this combo is already in place
Subscription?existingSub = await subRepo.FindByUserAndSpace(input.User.Username, input.Space);
if (existingSub != null)
{
return(subscriptionMapper.Map(existingSub));
}
//Create the subscription
Subscription sub = new Subscription()
{
Space = space,
User = input.User
};
await subRepo.Add(sub);
//Update sub count
space.SubscriptionCount++;
await spaceRepo.Update(space);
return(subscriptionMapper.Map(sub));
}
}
protected override async Task <SpaceView> HandleInput(SpaceUpdateParams input)
{
using (var connection = database.GetConnection()) {
ISpaceRepo spaceRepo = database.GetRepo <ISpaceRepo>(connection);
Space?s = await spaceRepo.FindByName(input.Name);
if (s == null)
{
throw new InvalidOperationException();
}
if (!(await this.spacePermissionHandler.HasPermission(input.User, PermissionAction.UpdateSpace, s)))
{
throw new AuthorizationException();
}
s.Description = input.Description;
await spaceRepo.Update(s);
return(spaceMapper.Map(s));
}
}
protected override async Task <SpaceView> HandleInput(SpaceCreateParams input)
{
using (var connection = database.GetConnection()) {
ISpaceRepo spaceRepo = database.GetRepo <ISpaceRepo>(connection);
Space? existing = await spaceRepo.FindByName(input.Name);
if (existing != null)
{
throw new InvalidOperationException($"Space name {input.Name} is already taken.");
}
Space s = new Space()
{
Name = input.Name,
Description = input.Description,
User = input.User,
CreationDate = DateTime.UtcNow
};
await spaceRepo.Add(s);
return(spaceMapper.Map(s));
}
}
public UserRegisterEventHandler(ISpaceRepo spaceRepo, ISubscriptionRepo subscriptionRepo, ISubscriptionFactory subscriptionFactory)
{
this.spaceRepo = spaceRepo;
this.subscriptionRepo = subscriptionRepo;
this.subscriptionFactory = subscriptionFactory;
}
public SubscriptionDeleteEventHandler(ISpaceRepo repo)
{
this.repo = repo;
}
public SpaceService(IEventBus bus, ISpaceFactory factory, ISpaceRepo repo)
{
this.bus = bus;
this.factory = factory;
this.repo = repo;
}
public SubscriptionService(IEventBus bus, ISubscriptionFactory factory, ISpaceRepo spaceRepo, ISubscriptionRepo repo) {
this.bus = bus;
this.factory = factory;
this.spaceRepo = spaceRepo;
this.repo = repo;
}