public WardenSpawnModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IIdentityProvider identityProvider)
: base(commandDispatcher, validatorResolver, identityProvider,
modulePath: "organizations/{organizationId}/wardens/{wardenId}/manager")
{
Post("start", async args => await For <StartWarden>()
.OnSuccessAccepted()
.DispatchAsync());
Post("pause", async args => await For <PauseWarden>()
.OnSuccessAccepted()
.DispatchAsync());
Post("stop", async args => await For <StopWarden>()
.OnSuccessAccepted()
.DispatchAsync());
Post("ping", async args => await For <PingWarden>()
.OnSuccessAccepted()
.DispatchAsync());
Delete("", async args => await For <KillWarden>()
.OnSuccessAccepted()
.DispatchAsync());
}
public ApiKeysModule(ICommandDispatcher commandDispatcher,
IIdentityProvider identityProvider,
IValidatorResolver validatorResolver,
IApiKeyStorage apiKeyStorage)
: base(commandDispatcher, validatorResolver, identityProvider, modulePath: "api-keys")
{
Get("", async args => await FetchCollection <BrowseApiKeys, ApiKey>
(async x => await apiKeyStorage.BrowseAsync(x))
.MapTo(x => new
{
Name = x.Name,
Key = x.Key
})
.HandleAsync());
Get("{name}", async args => await Fetch <GetApiKey, ApiKey>
(async x => await apiKeyStorage.GetAsync(x.UserId, x.Name))
.MapTo(x => new
{
Name = x.Name,
Key = x.Key
})
.HandleAsync());
Post("", async args => await For <RequestNewApiKey>()
.OnSuccessAccepted("api-keys")
.DispatchAsync());
Delete("{name}", async args => await For <DeleteApiKey>()
.OnSuccess(HttpStatusCode.NoContent)
.DispatchAsync());
}
public DevelopmentModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IOperationStorage operationStorage)
: base(commandDispatcher, validatorResolver, modulePath: "development")
{
Get("operation", args =>
{
RequestCounter++;
if (RequestCounter <= 2)
{
return(HttpStatusCode.NotFound);
}
if (RequestCounter == 3)
{
return(HttpStatusCode.Unauthorized);
}
if (RequestCounter == 8)
{
RequestCounter = 0;
}
return(new Operation
{
Id = Guid.NewGuid(),
RequestId = Guid.NewGuid(),
CreatedAt = DateTime.UtcNow,
State = "completed"
});
});
}
public RemarkCommentModule(ICommandDispatcher commandDispatcher,
IRemarkStorage remarkStorage,
IValidatorResolver validatorResolver)
: base(commandDispatcher, validatorResolver, modulePath: "remarks/{remarkId}/comments")
{
Post("", async args => await For <AddCommentToRemark>()
.SetResourceId(x => x.CommentId)
.OnSuccessAccepted(x => $"remarks/{x.RemarkId}/comments/" + "{0}")
.DispatchAsync());
Put("{commentId}", async args => await For <EditRemarkComment>()
.OnSuccessAccepted()
.DispatchAsync());
Delete("{commentId}", async args => await For <DeleteRemarkComment>()
.OnSuccessAccepted()
.DispatchAsync());
Put("{commentId}/votes", async args => await For <SubmitRemarkCommentVote>()
.Set(x => x.CreatedAt = DateTime.UtcNow)
.OnSuccessAccepted()
.DispatchAsync());
Delete("{commentId}/votes", async args => await For <DeleteRemarkCommentVote>()
.OnSuccessAccepted()
.DispatchAsync());
}
public StatisticsModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IStatisticsStorage statisticsStorage)
: base(commandDispatcher, validatorResolver, modulePath: "statistics")
{
Get("remarks", async args => await FetchCollection <BrowseRemarkStatistics, RemarkStatistics>
(async x => await statisticsStorage.BrowseRemarkStatisticsAsync(x))
.HandleAsync());
Get("remarks/{id}", async args => await Fetch <GetRemarkStatistics, RemarkStatistics>
(async x => await statisticsStorage.GetRemarkStatisticsAsync(x))
.HandleAsync());
Get("remarks/general", async args => await Fetch <GetRemarksCountStatistics, RemarksCountStatistics>
(async x => await statisticsStorage.GetRemarksCountStatisticsAsync(x))
.HandleAsync());
Get("categories", async args => await FetchCollection <BrowseCategoryStatistics, CategoryStatistics>
(async x => await statisticsStorage.BrowseCategoryStatisticsAsync(x))
.HandleAsync());
Get("tags", async args => await FetchCollection <BrowseTagStatistics, TagStatistics>
(async x => await statisticsStorage.BrowseTagStatisticsAsync(x))
.HandleAsync());
Get("users", async args => await FetchCollection <BrowseUserStatistics, UserStatistics>
(async x => await statisticsStorage.BrowseUserStatisticsAsync(x))
.HandleAsync());
Get("users/{id}", async args => await Fetch <GetUserStatistics, UserStatistics>
(async x => await statisticsStorage.GetUserStatisticsAsync(x))
.HandleAsync());
}
public OrganizationsModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IIdentityProvider identityProvider,
IOrganizationStorage organizationStorage)
: base(commandDispatcher, validatorResolver, identityProvider, modulePath: "organizations")
{
Get("", async args => await FetchCollection <BrowseOrganizations, Organization>
(async x => await organizationStorage.BrowseAsync(x))
.HandleAsync());
Get("{id}", async args => await Fetch <GetOrganization, Organization>
(async x => await organizationStorage.GetAsync(x.UserId, x.Id))
.HandleAsync());
Post("", async args => await For <RequestNewOrganization>()
.SetResourceId(x => x.OrganizationId)
.OnSuccessAccepted("organizations/{0}")
.DispatchAsync());
Put("{id}", async args => await For <UpdateOrganization>()
.OnSuccess(HttpStatusCode.NoContent)
.DispatchAsync());
Delete("{id}", async args => await For <DeleteOrganization>()
.OnSuccess(HttpStatusCode.NoContent)
.DispatchAsync());
}
public OrganizationModule(ICommandDispatcher commandDispatcher,
IOrganizationStorage organizationStorage,
IValidatorResolver validatorResolver)
: base(commandDispatcher, validatorResolver, modulePath: "organizations")
{
Get("{id}", async args => await Fetch <GetOrganization, Organization>
(async x => await organizationStorage.GetAsync(x.Id)).HandleAsync());
Get("", async args => await FetchCollection <BrowseOrganizations, Organization>
(async x => await organizationStorage.BrowseAsync(x))
.MapTo(x => new BasicOrganization
{
Id = x.Id,
Name = x.Name,
Codename = x.Codename,
IsPublic = x.IsPublic,
State = x.State,
CreatedAt = x.CreatedAt,
MembersCount = x.Members?.Count ?? 0,
GroupsCount = x.Groups?.Count ?? 0
}).HandleAsync());
Post("", async args => await For <CreateOrganization>()
.SetResourceId(x => x.OrganizationId)
.OnSuccessAccepted("organizations/{0}")
.DispatchAsync());
Post("{organizationId}/members", async args => await ForModerator <AddMemberToOrganization>()
.OnSuccessAccepted("organizations/{0}")
.DispatchAsync());
}
public StoreController(ILogger <StoreController> logger, IStore store, IValidatorResolver resolver, IConfiguration configuration)
{
_logger = logger;
this.store = store;
this.resolver = resolver;
this.configuration = configuration;
}
public UserModule(ICommandDispatcher commandDispatcher,
IUserStorage userStorage,
IValidatorResolver validatorResolver,
AppSettings settings)
: base(commandDispatcher, validatorResolver, modulePath: "users")
{
Get("", async args => await FetchCollection <BrowseUsers, UserInfo>
(async x => await userStorage.BrowseAsync(x)).HandleAsync());
Get("{name}", async args => await Fetch <GetUserByName, UserInfo>
(async x => await userStorage.GetInfoByNameAsync(x.Name)).HandleAsync());
Get("{id}/avatar", args =>
{
var query = BindRequest <GetAvatar>();
if (query.Id.Empty())
{
return(HttpStatusCode.NotFound);
}
return(Response.AsRedirect(string.Format(settings.AvatarUrl, query.Id)));
});
Put("{lockUserId}/lock", async args => await ForModerator <LockAccount>()
.OnSuccessAccepted()
.DispatchAsync());
Put("{unlockUserId}/unlock", async args => await ForModerator <UnlockAccount>()
.OnSuccessAccepted()
.DispatchAsync());
Post("", async(ctx, p) => await ForAdministrator <SignUp>()
.OnSuccessAccepted()
.DispatchAsync());
}
public HomeModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IIdentityProvider identityProvider)
: base(commandDispatcher, validatorResolver, identityProvider)
{
Get("", args => "Welcome to the Warden API!");
}
public UserService(DataContext dataContext, IMapper mapper,
IValidatorResolver validatorResolver, ILogger <UserService> logger)
{
_dataContext = dataContext;
_validatorResolver = validatorResolver;
_logger = logger;
}
public WardensModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IIdentityProvider identityProvider,
IOrganizationStorage organizationStorage)
: base(commandDispatcher, validatorResolver, identityProvider,
modulePath: "organizations/{organizationId}/wardens")
{
Get("{wardenId}", async args => await Fetch <GetWarden, Warden.Services.Storage.Models.Organizations.Warden>
(async x => await organizationStorage.GetWardenAsync(x.UserId, x.OrganizationId, x.WardenId))
.HandleAsync());
Post("", async args => await For <RequestNewWarden>()
.SetResourceId(x => x.WardenId)
.OnSuccessAccepted($"organizations/{args.organizationId}/wardens/" + "{0}")
.DispatchAsync());
Post("external", async args => await For <CreateExternalWarden>()
.SetResourceId(x => x.WardenId)
.OnSuccessAccepted($"organizations/{args.organizationId}/wardens/" + "{0}")
.DispatchAsync());
Delete("{wardenId}", async args => await For <DeleteWarden>()
.OnSuccessAccepted()
.DispatchAsync());
}
protected ModuleBase(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
string modulePath = "")
: base(modulePath)
{
CommandDispatcher = commandDispatcher;
_validatorResolver = validatorResolver;
}
public RemarkReportModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver)
: base(commandDispatcher, validatorResolver, modulePath: "remarks/{remarkId}/reports")
{
Post("", async args => await For <ReportRemark>()
.OnSuccessAccepted()
.DispatchAsync());
}
public OperationModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IOperationProvider operationProvider)
: base(commandDispatcher, validatorResolver, modulePath: "operations")
{
Get("{requestId}", args => Fetch <GetOperation, Operation>
(async x => await operationProvider.GetAsync(x.RequestId)).HandleAsync());
}
public CommandsGateway(
ICommandHandlerResolver commandHandlerResolver,
Func <IDisposable> scopeFactory,
IValidatorResolver validatorResolver)
{
_commandHandlerResolver = commandHandlerResolver;
_scopeFactory = scopeFactory;
_validationFacade = new ValidationFacade(validatorResolver);
}
public SupportModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver)
: base(commandDispatcher, validatorResolver, modulePath: "support")
{
Post("mailing", async args => await For <SendSupportEmailMessage>()
.Set(x => x.Title = $"Support message from: {x.Email}")
.OnSuccessAccepted()
.DispatchAsync());
}
public WardenChecksModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IIdentityProvider identityProvider)
: base(commandDispatcher, validatorResolver, identityProvider,
modulePath: "organizations/{organizationId}/wardens/{wardenId}/checks")
{
Post("", async args => await For <RequestProcessWardenCheckResult>()
.SetResourceId(x => x.ResultId)
.OnSuccessAccepted($"organizations/{args.organizationId}/wardens/{args.wardenId}/checks/" + "{0}")
.DispatchAsync());
}
public UserApiController(ILogger <UserApiController> logger,
IUserService userService,
IValidatorResolver validatorResolver,
IMapper mapper
)
{
_logger = logger;
_userService = userService;
_validatorResolver = validatorResolver;
_mapper = mapper;
}
public UserModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IIdentityProvider identityProvider)
: base(commandDispatcher, validatorResolver, identityProvider, modulePath: "users")
{
Put("assign", async args => await For <AssignUserToOrganization>()
.DispatchAsync());
Put("unassign", async args => await For <UnassignUserFromOrganization>()
.DispatchAsync());
}
public AccountModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IUserStorage userStorage,
INotificationSettingsStorage notificationSettingsStorage)
: base(commandDispatcher, validatorResolver)
{
Get("account", async args => await Fetch <GetAccount, User>
(async x => await userStorage.GetAsync(x.UserId)).HandleAsync());
Get("account/settings/notifications", async args => await Fetch <GetNotificationSettings, UserNotificationSettings>
(async x => await notificationSettingsStorage.GetAsync(x.UserId))
.HandleAsync());
Get("account/names/{name}/available", async args => await Fetch <GetNameAvailability, AvailableResource>
(async x => await userStorage.IsNameAvailableAsync(x.Name)).HandleAsync());
Put("account/name", async args => await For <ChangeUsername>()
.OnSuccessAccepted("account")
.DispatchAsync());
Put("account/settings/notifications", async args => await For <UpdateUserNotificationSettings>()
.OnSuccessAccepted("account")
.DispatchAsync());
Post("sign-up", async(ctx, p) => await For <SignUp>()
.Set(x =>
{
x.Role = string.Empty;
x.State = string.Empty;
})
.OnSuccessAccepted("account")
.DispatchAsync());
Post("account/avatar", async args => await For <UploadAvatar>()
.OnSuccessAccepted("account")
.DispatchAsync());
Post("account/activate", async args => await For <ActivateAccount>()
.OnSuccessAccepted("account")
.DispatchAsync());
Delete("account/avatar", async args => await For <RemoveAvatar>()
.OnSuccessAccepted()
.DispatchAsync());
Put("account/password", async args => await For <ChangePassword>()
.OnSuccessAccepted("account")
.DispatchAsync());
Delete("account", async args => await For <DeleteAccount>()
.OnSuccessAccepted()
.DispatchAsync());
}
public CommandRequestHandler(ICommandDispatcher dispatcher, T command,
IResponseFormatter responseFormatter,
IValidatorResolver validatorResolver,
Negotiator negotiator,
Url url, string culture)
{
_dispatcher = dispatcher;
_command = command;
_command.Request = Messages.Commands.Request.Create <T>(Guid.NewGuid(), url.Path, culture);
_responseFormatter = responseFormatter;
_validatorResolver = validatorResolver;
_negotiator = negotiator;
}
public CommandRequestHandler(ICommandDispatcher dispatcher, T command,
IResponseFormatter responseFormatter,
IValidatorResolver validatorResolver,
Negotiator negotiator,
Messages.Commands.Request request)
{
_dispatcher = dispatcher;
_command = command;
_command.Request = request;
_responseFormatter = responseFormatter;
_validatorResolver = validatorResolver;
_negotiator = negotiator;
}
public ProductApiController(ILogger <ProductApiController> logger,
IUserService userService,
IProductService productService,
IValidatorResolver validatorResolver,
IMapper mapper
)
{
_logger = logger;
_userService = userService;
_productService = productService;
_validatorResolver = validatorResolver;
_mapper = mapper;
}
public UserFavoriteModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IUserStorage userStorage)
: base(commandDispatcher, validatorResolver, "account/favorites")
{
Put("remarks/{remarkId}", async args => await For <AddFavoriteRemark>()
.OnSuccessAccepted()
.DispatchAsync());
Delete("remarks/{remarkId}", async args => await For <DeleteFavoriteRemark>()
.OnSuccessAccepted()
.DispatchAsync());
}
public ResetPasswordModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver, AppSettings appSettings)
: base(commandDispatcher, validatorResolver, "reset-password")
{
Post("", async args => await For <ResetPassword>()
.Set(x => x.Endpoint = appSettings.ResetPasswordUrl)
.OnSuccessAccepted()
.DispatchAsync());
Post("set-new", async args => await For <SetNewPassword>()
.OnSuccessAccepted()
.DispatchAsync());
}
public RemarkActionModule(ICommandDispatcher commandDispatcher,
IRemarkStorage remarkStorage,
IValidatorResolver validatorResolver)
: base(commandDispatcher, validatorResolver, modulePath: "remarks/{remarkId}/actions")
{
Post("", async args => await For <TakeRemarkAction>()
.OnSuccessAccepted()
.DispatchAsync());
Delete("", async args => await For <CancelRemarkAction>()
.OnSuccessAccepted()
.DispatchAsync());
}
public ItemApiController(ILogger <ItemApiController> logger,
IStringLocalizer <ItemApiController> localizer,
IUserService userService,
IUserItemService userItemService,
IValidatorResolver validatorResolver,
IMapper mapper
)
{
_logger = logger;
_userService = userService;
_userItemService = userItemService;
_validatorResolver = validatorResolver;
_mapper = mapper;
_localizer = localizer;
}
public UserApiController(ILogger <UserApiController> logger,
IStringLocalizer <UserApiController> localizer,
IUserService userService,
IShopExternalService shopExternalService,
IValidatorResolver validatorResolver,
IMapper mapper
)
{
_logger = logger;
_userService = userService;
_shopExternalService = shopExternalService;
_validatorResolver = validatorResolver;
_mapper = mapper;
_localizer = localizer;
}
public AuthenticationModule(ICommandDispatcher commandDispatcher,
IValidatorResolver validatorResolver,
IIdentityProvider identityProvider,
IUserStorage userStorage,
IOperationStorage operationStorage,
IJwtTokenHandler jwtTokenHandler,
JwtTokenSettings jwtTokenSettings)
: base(commandDispatcher, validatorResolver, identityProvider, modulePath: "")
{
Post("sign-in", async(ctx, p) => await For <SignIn>()
.Set(c =>
{
c.IpAddress = Request.UserHostAddress;
c.UserAgent = Request.Headers.UserAgent;
})
.SetResourceId(c => c.SessionId)
.OnSuccess(async c =>
{
var operation = await operationStorage.GetUpdatedAsync(c.Request.Id);
if (operation.HasNoValue || !operation.Value.Success)
{
return(HttpStatusCode.Unauthorized);
}
var session = await userStorage.GetSessionAsync(c.SessionId);
if (session.HasNoValue)
{
return(HttpStatusCode.Unauthorized);
}
return(new
{
token = jwtTokenHandler.Create(session.Value.UserId),
sessionId = session.Value.Id,
sessionKey = session.Value.Key,
expiry = DateTime.UtcNow.AddDays(jwtTokenSettings.ExpiryDays).ToTimestamp()
});
})
.DispatchAsync());
Post("sign-up", async args => await For <SignUp>()
.OnSuccessAccepted("account")
.DispatchAsync());
Post("sign-out", async args => await For <SignOut>()
.OnSuccess(HttpStatusCode.NoContent)
.DispatchAsync());
}
