Skip to content

Commit 1a7df22

Browse files
StuartFergusonStuartFerguson
committed
change system setup tool to support using results
1 parent d68cced commit 1a7df22

6 files changed

Lines changed: 953 additions & 754 deletions

File tree

‎TransactionProcessor.SystemSetupTool/EstateSetupFunctions.cs‎

Lines changed: 567 additions & 0 deletions
Large diffs are not rendered by default.

‎TransactionProcessor.SystemSetupTool/EventStoreFunctions.cs‎

Lines changed: 122 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,122 @@
1+
using System;
2+
using System.Collections.Generic;
3+
using System.IO;
4+
using System.Linq;
5+
using System.Threading;
6+
using System.Threading.Tasks;
7+
using EventStore.Client;
8+
using SimpleResults;
9+
10+
namespace TransactionProcessor.SystemSetupTool;
11+
12+
public class EventStoreFunctions{
13+
private readonly EventStoreProjectionManagementClient ProjectionClient;
14+
15+
private readonly EventStorePersistentSubscriptionsClient PersistentSubscriptionsClient;
16+
17+
public EventStoreFunctions(EventStoreProjectionManagementClient projectionClient,EventStorePersistentSubscriptionsClient persistentSubscriptionsClient){
18+
this.ProjectionClient = projectionClient;
19+
this.PersistentSubscriptionsClient = persistentSubscriptionsClient;
20+
}
21+
22+
private static PersistentSubscriptionSettings CreatePersistentSettings(Int32 retryCount = 0) => new PersistentSubscriptionSettings(resolveLinkTos: true, maxRetryCount: retryCount, startFrom:new StreamPosition(0));
23+
24+
public async Task<Result> SetupEventStore(CancellationToken cancellationToken)
25+
{
26+
await this.DeployProjections(cancellationToken);
27+
await this.SetupSubscriptions(cancellationToken);
28+
29+
return Result.Success();
30+
}
31+
32+
private async Task<Result> SetupSubscriptions(CancellationToken cancellationToken){
33+
List<(String streamName, String groupName, Int32 retryCount)> subscriptions = new List<(String streamName, String groupName, Int32 retryCount)>();
34+
subscriptions.Add(("$ce-TransactionAggregate", "Transaction Processor", 0));
35+
subscriptions.Add(("$ce-SettlementAggregate", "Transaction Processor", 0));
36+
subscriptions.Add(("$ce-VoucherAggregate", "Transaction Processor", 0));
37+
subscriptions.Add(("$ce-FloatAggregate", "Transaction Processor", 0));
38+
39+
subscriptions.Add(("$ce-EstateAggregate", "Transaction Processor - Ordered", 1));
40+
subscriptions.Add(("$ce-SettlementAggregate", "Transaction Processor - Ordered", 1));
41+
subscriptions.Add(("$ce-VoucherAggregate", "Transaction Processor - Ordered", 1));
42+
43+
subscriptions.Add(("$ce-TransactionAggregate", "Estate Management", 0));
44+
subscriptions.Add(("$ce-SettlementAggregate", "Estate Management", 0));
45+
subscriptions.Add(("$ce-VoucherAggregate", "Estate Management", 0));
46+
subscriptions.Add(("$ce-MerchantStatementAggregate", "Estate Management", 0));
47+
subscriptions.Add(("$ce-ContractAggregate", "Estate Management", 0));
48+
subscriptions.Add(("$ce-EstateAggregate", "Estate Management", 0));
49+
subscriptions.Add(("$ce-MerchantAggregate", "Estate Management", 0));
50+
subscriptions.Add(("$ce-CallbackMessageAggregate", "Estate Management", 0));
51+
subscriptions.Add(("$ce-ReconciliationAggregate", "Estate Management", 0));
52+
subscriptions.Add(("$ce-FileAggregate", "Estate Management", 0));
53+
subscriptions.Add(("$ce-FileImportLogAggregate", "Estate Management", 0));
54+
subscriptions.Add(("$ce-OperatorAggregate", "Estate Management", 0));
55+
56+
subscriptions.Add(("$ce-TransactionAggregate", "Estate Management - Ordered", 0));
57+
subscriptions.Add(("$ce-MerchantStatementAggregate", "Estate Management - Ordered", 0));
58+
subscriptions.Add(("$ce-EstateAggregate", "Estate Management - Ordered", 0));
59+
subscriptions.Add(("$ce-FileAggregate", "File Processor", 0));
60+
subscriptions.Add(("$ce-FileImportLogAggregate", "File Processor", 0));
61+
subscriptions.Add(("$ce-EmailAggregate", "Messaging Service", 0));
62+
subscriptions.Add(("$ce-SMSAggregate", "Messaging Service", 0));
63+
64+
foreach ((String streamName, String groupName, Int32 retryCount) subscription in subscriptions){
65+
Boolean exists = false;
66+
try{
67+
PersistentSubscriptionInfo subscriptionInfo = await this.PersistentSubscriptionsClient.GetInfoToStreamAsync(subscription.streamName, subscription.groupName, cancellationToken: cancellationToken, deadline:TimeSpan.FromSeconds(30));
68+
exists = true;
69+
}
70+
catch(PersistentSubscriptionNotFoundException pex){
71+
exists = false;
72+
}
73+
74+
if (exists == false){
75+
await this.PersistentSubscriptionsClient.CreateToStreamAsync(subscription.streamName, subscription.groupName, CreatePersistentSettings(subscription.retryCount), cancellationToken: cancellationToken, deadline: TimeSpan.FromSeconds(30));
76+
}
77+
}
78+
79+
return Result.Success();
80+
}
81+
private async Task<Result> DeployProjections(CancellationToken cancellationToken)
82+
{
83+
var currentProjections = await this.ProjectionClient.ListAllAsync(cancellationToken: cancellationToken).ToListAsync(cancellationToken);
84+
85+
var projectionsToDeploy = Directory.GetFiles("projections/continuous");
86+
87+
foreach (var projection in projectionsToDeploy)
88+
{
89+
if (projection.Contains("EstateManagementSubscriptionStreamBuilder") ||
90+
projection.Contains("FileProcessorSubscriptionStreamBuilder") ||
91+
projection.Contains("TransactionProcessorSubscriptionStreamBuilder"))
92+
{
93+
continue;
94+
}
95+
96+
FileInfo f = new FileInfo(projection);
97+
String name = f.Name.Substring(0, f.Name.Length - (f.Name.Length - f.Name.LastIndexOf(".")));
98+
var body = File.ReadAllText(f.FullName);
99+
100+
var x = body.IndexOf("//endtestsetup");
101+
x = x + "//endtestsetup".Length;
102+
103+
body = body.Substring(x);
104+
105+
// Is this already deployed (in the master list)
106+
if (currentProjections.Any(p => p.Name == name) == false)
107+
{
108+
// Projection does not exist so create
109+
await this.ProjectionClient.CreateContinuousAsync(name, body, true, cancellationToken: cancellationToken);
110+
}
111+
else
112+
{
113+
// Already exists so we need to update but do not reset
114+
await this.ProjectionClient.DisableAsync(name, cancellationToken: cancellationToken);
115+
await this.ProjectionClient.UpdateAsync(name, body, true, cancellationToken: cancellationToken);
116+
await this.ProjectionClient.EnableAsync(name, cancellationToken: cancellationToken);
117+
}
118+
}
119+
120+
return Result.Success();
121+
}
122+
}

‎TransactionProcessor.SystemSetupTool/IdentityServerFunctions.cs‎

Lines changed: 222 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,222 @@
1+
using System;
2+
using System.Collections.Generic;
3+
using System.Linq;
4+
using System.Threading;
5+
using System.Threading.Tasks;
6+
using Microsoft.AspNetCore.Mvc;
7+
using Microsoft.AspNetCore.Rewrite;
8+
using SecurityService.Client;
9+
using SecurityService.DataTransferObjects.Requests;
10+
using SecurityService.DataTransferObjects.Responses;
11+
using Shared.Results;
12+
using SimpleResults;
13+
using TransactionProcessor.SystemSetupTool.identityserverconfig;
14+
15+
namespace TransactionProcessor.SystemSetupTool;
16+
17+
public class IdentityServerFunctions{
18+
private readonly ISecurityServiceClient SecurityServiceClient;
19+
20+
private readonly IdentityServerConfiguration identityServerConfiguration;
21+
22+
public IdentityServerFunctions(ISecurityServiceClient securityServiceClient, IdentityServerConfiguration configuration){
23+
this.SecurityServiceClient = securityServiceClient;
24+
this.identityServerConfiguration = configuration;
25+
}
26+
27+
private async Task<Result> CreateRoles(CancellationToken cancellationToken) {
28+
Result<List<RoleDetails>> rolesResult = await this.SecurityServiceClient.GetRoles(cancellationToken);
29+
if (rolesResult.IsFailed)
30+
return ResultHelpers.CreateFailure(rolesResult);
31+
32+
List<RoleDetails> roles = rolesResult.Data;
33+
if (roles == null)
34+
roles = new List<RoleDetails>();
35+
36+
foreach (String role in this.identityServerConfiguration.roles)
37+
{
38+
if (roles.Any(r => r.RoleName == role))
39+
continue;
40+
Result createResult = await this.CreateRole(role, CancellationToken.None);
41+
if (createResult.IsFailed)
42+
return ResultHelpers.CreateFailure(createResult);
43+
}
44+
45+
return Result.Success();
46+
}
47+
48+
private async Task<Result> CreateApiResources(CancellationToken cancellationToken) {
49+
var apiResourcesResult = await this.SecurityServiceClient.GetApiResources(cancellationToken);
50+
if (apiResourcesResult.IsFailed)
51+
return ResultHelpers.CreateFailure(apiResourcesResult);
52+
53+
var apiResources = apiResourcesResult.Data;
54+
if (apiResources == null)
55+
apiResources = new List<ApiResourceDetails>();
56+
foreach (ApiResource apiResource in this.identityServerConfiguration.apiresources)
57+
{
58+
if (apiResources.Any(a => a.Name == apiResource.name))
59+
continue;
60+
var createResult = await this.CreateApiResource(apiResource, CancellationToken.None);
61+
if (createResult.IsFailed)
62+
return ResultHelpers.CreateFailure(createResult);
63+
}
64+
return Result.Success();
65+
}
66+
67+
private async Task<Result> CreateIdentityResources(CancellationToken cancellationToken) {
68+
var identityResourcesResult = await this.SecurityServiceClient.GetIdentityResources(cancellationToken);
69+
if (identityResourcesResult.IsFailed)
70+
return ResultHelpers.CreateFailure(identityResourcesResult);
71+
72+
var identityResources = identityResourcesResult.Data;
73+
if (identityResources == null)
74+
identityResources = new List<IdentityResourceDetails>();
75+
76+
foreach (IdentityResource identityResource in this.identityServerConfiguration.identityresources)
77+
{
78+
if (identityResources.Any(i => i.Name == identityResource.name))
79+
continue;
80+
var createResult = await this.CreateIdentityResource(identityResource, CancellationToken.None);
81+
if (createResult.IsFailed)
82+
return ResultHelpers.CreateFailure(createResult);
83+
}
84+
return Result.Success();
85+
}
86+
87+
private async Task<Result> CreateClients(CancellationToken cancellationToken) {
88+
var clientsResult = await this.SecurityServiceClient.GetClients(cancellationToken);
89+
if (clientsResult.IsFailed)
90+
return ResultHelpers.CreateFailure(clientsResult);
91+
92+
var clients = clientsResult.Data;
93+
if (clients == null)
94+
clients = new List<ClientDetails>();
95+
foreach (identityserverconfig.Client client in this.identityServerConfiguration.clients)
96+
{
97+
if (clients.Any(c => c.ClientId == client.client_id))
98+
continue;
99+
var createResult = await this.CreateClient(client, CancellationToken.None);
100+
if (createResult.IsFailed)
101+
return ResultHelpers.CreateFailure(createResult);
102+
}
103+
104+
return Result.Success();
105+
}
106+
107+
private async Task<Result> CreateApiScopes(CancellationToken cancellationToken) {
108+
var apiScopesResult = await this.SecurityServiceClient.GetApiScopes(cancellationToken);
109+
if (apiScopesResult.IsFailed)
110+
return ResultHelpers.CreateFailure(apiScopesResult);
111+
var apiScopes = apiScopesResult.Data;
112+
if(apiScopes == null)
113+
apiScopes = new List<ApiScopeDetails>();
114+
foreach (ApiScope apiscope in this.identityServerConfiguration.apiscopes)
115+
{
116+
if (apiScopes.Any(a => a.Name== apiscope.name))
117+
continue;
118+
var createResult = await this.CreateApiScope(apiscope, CancellationToken.None);
119+
if (createResult.IsFailed)
120+
return ResultHelpers.CreateFailure(createResult);
121+
}
122+
return Result.Success();
123+
}
124+
125+
public async Task<Result> CreateConfig(CancellationToken cancellationToken) {
126+
127+
Result createRolesResult = await this.CreateRoles(cancellationToken);
128+
if (createRolesResult.IsFailed)
129+
return createRolesResult;
130+
131+
Result createApiResourcesResult = await this.CreateApiResources(cancellationToken);
132+
if (createApiResourcesResult.IsFailed)
133+
return createApiResourcesResult;
134+
135+
Result createIdentityResourcesResult = await this.CreateIdentityResources(cancellationToken);
136+
if (createIdentityResourcesResult.IsFailed)
137+
return createIdentityResourcesResult;
138+
139+
Result createClientsResult = await this.CreateClients(cancellationToken);
140+
if (createClientsResult.IsFailed)
141+
return createClientsResult;
142+
143+
Result createApiScopesResult = await this.CreateApiScopes(cancellationToken);
144+
if (createApiScopesResult.IsFailed)
145+
return createApiScopesResult;
146+
147+
return Result.Success();
148+
}
149+
150+
private async Task<Result> CreateRole(String role, CancellationToken cancellationToken){
151+
152+
CreateRoleRequest createRoleRequest = new() {
153+
RoleName = role
154+
};
155+
156+
return await this.SecurityServiceClient.CreateRole(createRoleRequest, cancellationToken);
157+
}
158+
159+
private async Task<Result> CreateApiScope(ApiScope apiscope,
160+
CancellationToken cancellationToken)
161+
{
162+
CreateApiScopeRequest createApiScopeRequest = new CreateApiScopeRequest
163+
{
164+
Description = apiscope.description,
165+
DisplayName = apiscope.display_name,
166+
Name = apiscope.name
167+
};
168+
169+
return await this.SecurityServiceClient.CreateApiScope(createApiScopeRequest, cancellationToken);
170+
}
171+
172+
private async Task<Result> CreateIdentityResource(IdentityResource identityResource,
173+
CancellationToken cancellationToken)
174+
{
175+
CreateIdentityResourceRequest createIdentityResourceRequest = new CreateIdentityResourceRequest
176+
{
177+
Claims = identityResource.claims,
178+
Description = identityResource.description,
179+
DisplayName = identityResource.displayName,
180+
Emphasize = identityResource.emphasize,
181+
Name = identityResource.name,
182+
Required = identityResource.required,
183+
ShowInDiscoveryDocument = identityResource.showInDiscoveryDocument
184+
};
185+
186+
return await this.SecurityServiceClient.CreateIdentityResource(createIdentityResourceRequest, cancellationToken);
187+
}
188+
189+
private async Task<Result> CreateClient(identityserverconfig.Client client, CancellationToken cancellationToken)
190+
{
191+
CreateClientRequest createClientRequest = new CreateClientRequest
192+
{
193+
AllowOfflineAccess = client.allow_offline_access.GetValueOrDefault(false),
194+
AllowedGrantTypes = client.allowed_grant_types,
195+
AllowedScopes = client.allowed_scopes,
196+
ClientDescription = client.client_description,
197+
ClientId = client.client_id,
198+
ClientName = client.client_name,
199+
ClientPostLogoutRedirectUris = client.client_post_logout_redirect_uris,
200+
ClientRedirectUris = client.client_redirect_uris,
201+
RequireConsent = client.require_consent.GetValueOrDefault(false),
202+
Secret = client.secret
203+
};
204+
return await this.SecurityServiceClient.CreateClient(createClientRequest, cancellationToken);
205+
}
206+
207+
private async Task<Result> CreateApiResource(ApiResource apiResource,
208+
CancellationToken cancellationToken)
209+
{
210+
CreateApiResourceRequest createApiResourceRequest = new CreateApiResourceRequest
211+
{
212+
Secret = apiResource.secret,
213+
Description = apiResource.description,
214+
DisplayName = apiResource.display_name,
215+
Name = apiResource.name,
216+
Scopes = apiResource.scopes,
217+
UserClaims = apiResource.user_claims
218+
};
219+
220+
return await this.SecurityServiceClient.CreateApiResource(createApiResourceRequest, cancellationToken);
221+
}
222+
}

0 commit comments

Comments
 (0)