protected override void AddArguments()
{
_nameArg = CommandArgumentValue.AddArgument("un", "userName", new[] { "User name" }, true,
1);
_passwordArg = CommandArgumentValue.AddArgument("p", "password", new[] { "New password of user" }, true,
1);
}
protected override void AddArguments()
{
_clientUri = CommandArgumentValue.AddArgument("u", "clientUri", new[] { "URI of client" }, false, 1);
_redirectUri = CommandArgumentValue.AddArgument("ru", "redirectUri", new[] { "Redirect URI for login procedure" }, false, 1);
_clientId = CommandArgumentValue.AddArgument("id", "clientId", new[] { "ServiceClient ID, must be unique" }, false, 1);
_clientName = CommandArgumentValue.AddArgument("n", "name", new[] { "Display name of client used for grants" }, false, 1);
}
protected override void AddArguments()
{
_tenantIdArg = CommandArgumentValue.AddArgument("tid", "tenantId", new[] { "Id of tenant" },
true, 1);
_databaseArg = CommandArgumentValue.AddArgument("db", "database", new[] { "Name of database" }, true,
1);
}
public override Task Execute()
{
Logger.Info("Configuring the tool");
if (CommandArgumentValue.IsArgumentUsed(_tenantIdArg))
{
var tenantIdArgData = CommandArgumentValue.GetArgumentValue(_tenantIdArg);
Options.Value.TenantId = tenantIdArgData.GetValue <string>().ToLower();
}
if (CommandArgumentValue.IsArgumentUsed(_coreServicesUriArg))
{
var coreServicesUriData = CommandArgumentValue.GetArgumentValue(_coreServicesUriArg);
Options.Value.CoreServiceUrl = coreServicesUriData.GetValue <string>().ToLower();
}
if (CommandArgumentValue.IsArgumentUsed(_jobServicesUriArg))
{
var jobServicesUriData = CommandArgumentValue.GetArgumentValue(_jobServicesUriArg);
Options.Value.JobServiceUrl = jobServicesUriData.GetValue <string>().ToLower();
}
if (CommandArgumentValue.IsArgumentUsed(_identityServicesUriArg))
{
var identityServicesUriData = CommandArgumentValue.GetArgumentValue(_identityServicesUriArg);
Options.Value.IdentityServiceUrl = identityServicesUriData.GetValue <string>().ToLower();
}
_configWriter.WriteSettings(Constants.OspToolUserFolderName);
return(Task.CompletedTask);
}
protected override async Task WaitForJob(string id)
{
if (CommandArgumentValue.IsArgumentUsed(_waitForJobArg))
{
await base.WaitForJob(id);
}
}
protected override void AddArguments()
{
base.AddArguments();
_fileArg = CommandArgumentValue.AddArgument("f", "file", new[] { "File to import" }, true, 1);
_scopeArg = CommandArgumentValue.AddArgument("s", "scope", new[] { "Scope to import, available is 'Application', 'Layer2', 'Layer3' or 'Layer4'" }, true, 1);
}
protected override void AddArguments()
{
base.AddArguments();
_waitForJobArg = CommandArgumentValue.AddArgument("w", "wait",
new[] { "Wait for a import job to complete" }, false, 0);
}
public override async Task Execute()
{
var alias = CommandArgumentValue.GetArgumentScalarValue <string>(_alias);
var type = CommandArgumentValue.GetArgumentScalarValue <IdentityProviderTypesDto>(_type);
Logger.Info($"Creating identity provider '{@alias}' at '{ServiceClient.ServiceUri}'");
if (type == IdentityProviderTypesDto.Google)
{
var identityProviderDto = new GoogleIdentityProviderDto
{
IsEnabled = CommandArgumentValue.GetArgumentScalarValue <bool>(_enabled),
ClientId = CommandArgumentValue.GetArgumentScalarValue <string>(_clientId),
ClientSecret = CommandArgumentValue.GetArgumentScalarValueOrDefault <string>(_clientSecret),
Alias = alias
};
await ServiceClient.CreateIdentityProvider(identityProviderDto);
}
else if (type == IdentityProviderTypesDto.Microsoft)
{
var identityProviderDto = new MicrosoftIdentityProviderDto
{
IsEnabled = CommandArgumentValue.GetArgumentScalarValue <bool>(_enabled),
ClientId = CommandArgumentValue.GetArgumentScalarValue <string>(_clientId),
ClientSecret = CommandArgumentValue.GetArgumentScalarValueOrDefault <string>(_clientSecret),
Alias = alias
};
await ServiceClient.CreateIdentityProvider(identityProviderDto);
}
Logger.Info($"ServiceClient '{alias}' at '{ServiceClient.ServiceUri}' created.");
}
protected override void AddArguments()
{
_isEnabledArg = CommandArgumentValue.AddArgument("e", "enabled", new[] { "Enabled state of service hook" },
true, 1);
_nameArg = CommandArgumentValue.AddArgument("n", "name", new[] { "Display name of service hook" },
true, 1);
_ckIdArg = CommandArgumentValue.AddArgument("ck", "ckId",
new[] { "The construction kit id key the service hook is applied to" },
true, 1);
_filterArg = CommandArgumentValue.AddArgument("f", "filter", new[]
{
"Filter arguments in form \"'{AttributeName}' {Operator} '{Value}'\"",
"Sample: \"'State' Equals '2'\"",
"Attribute name must be a valid argument of the defined entity",
$"Possible operators: {string.Join(", ", Enum.GetNames(typeof(FieldFilterOperatorDto)))} ",
"Value must be a string, integer, double, boolean, DateTime"
},
true, 1, true);
_serviceHookBaseUriArg = CommandArgumentValue.AddArgument("u", "uri",
new[] { "The base uri of the service hook" },
false, 1);
_serviceHookActionArg = CommandArgumentValue.AddArgument("a", "action",
new[] { "The action uri of the service hook" },
false, 1);
}
protected override void AddArguments()
{
_eMailArg = CommandArgumentValue.AddArgument("e", "email",
new[] { "E-Mail of admin" }, 1);
_passwordArg = CommandArgumentValue.AddArgument("p", "password",
new[] { "Password of admin" }, 1);
}
public override async Task Execute()
{
var clientIdArgData = CommandArgumentValue.GetArgumentValue(_clientId);
var clientId = clientIdArgData.GetValue <string>();
var clientNameArgData = CommandArgumentValue.GetArgumentValue(_clientName);
var clientName = clientNameArgData.GetValue <string>();
var clientSecretArgData = CommandArgumentValue.GetArgumentValue(_clientSecret);
var clientSecret = clientSecretArgData.GetValue <string>();
Logger.Info($"Creating client '{clientId}' at '{ServiceClient.ServiceUri}'");
var clientDto = new ClientDto
{
IsEnabled = true,
ClientId = clientId,
ClientName = clientName,
ClientSecret = clientSecret,
AllowedGrantTypes = new[] { OidcConstants.GrantTypes.ClientCredentials },
AllowedScopes = new[] { CommonConstants.SystemApiFullAccess },
IsOfflineAccessEnabled = true
};
await ServiceClient.CreateClient(clientDto);
Logger.Info($"ServiceClient '{clientId}' at '{ServiceClient.ServiceUri}' created.");
}
public override async Task Execute()
{
var nameArgData = CommandArgumentValue.GetArgumentValue(_nameArg);
var name = nameArgData.GetValue <string>().ToLower();
string newUserName = null;
if (CommandArgumentValue.IsArgumentUsed(_newNameArg))
{
var newUserNameArgData = CommandArgumentValue.GetArgumentValue(_newNameArg);
newUserName = newUserNameArgData.GetValue <string>().ToLower();
}
string roleName = null;
if (CommandArgumentValue.IsArgumentUsed(_roleArg))
{
var roleArgData = CommandArgumentValue.GetArgumentValue(_roleArg);
roleName = roleArgData.GetValue <string>().ToLower();
}
string eMail = null;
if (CommandArgumentValue.IsArgumentUsed(_eMailArg))
{
var eMailArgData = CommandArgumentValue.GetArgumentValue(_eMailArg);
eMail = eMailArgData.GetValue <string>().ToLower();
}
Logger.Info($"Updating user '{name}' at '{ServiceClient.ServiceUri}'");
var userDto = new UserDto
{
Email = eMail,
Name = newUserName,
Roles = new List <RoleDto>()
};
if (!string.IsNullOrWhiteSpace(roleName))
{
RoleDto roleDto;
try
{
roleDto = await ServiceClient.GetRoleByName(roleName);
}
catch (ServiceClientResultException)
{
Logger.Error($"Role '{roleName}' does not exist at '{ServiceClient.ServiceUri}'");
return;
}
userDto.Roles = new[] { roleDto };
}
await ServiceClient.UpdateUser(name, userDto);
Logger.Info($"User '{name}' updated.");
}
public override async Task Execute()
{
var isEnabled = CommandArgumentValue.GetArgumentScalarValue <bool>(_isEnabledArg);
var name = CommandArgumentValue.GetArgumentScalarValue <string>(_nameArg);
var serviceHookBaseUri = CommandArgumentValue.GetArgumentScalarValue <string>(_serviceHookBaseUriArg);
var serviceHookAction = CommandArgumentValue.GetArgumentScalarValue <string>(_serviceHookActionArg);
var ckId = CommandArgumentValue.GetArgumentScalarValue <string>(_ckIdArg);
var filterArgData = CommandArgumentValue.GetArgumentValue(_filterArg);
Logger.Info(
$"Creating service hook for entity '{ckId}' at '{ServiceClient.ServiceUri}'");
List <FieldFilterDto> fieldFilters = new List <FieldFilterDto>();
foreach (var filterArg in filterArgData.Values)
{
var terms = filterArg.Split(" ");
if (terms.Length != 3)
{
throw new InvalidOperationException($"Filter term '{filterArg}' is invalid. Three terms needed.");
}
var attribute = terms[0].Trim('\'');
if (!Enum.TryParse(terms[1], true, out FieldFilterOperatorDto operatorDto))
{
throw new InvalidOperationException($"Operator '{terms[1]}' of term '{filterArg}' is invalid.");
}
var comparisionValue = terms[2].Trim('\'');
fieldFilters.Add(new FieldFilterDto
{
AttributeName = attribute, Operator = operatorDto, ComparisonValue = comparisionValue
});
}
var createServiceHookDto = new ServiceHookMutationDto
{
Enabled = isEnabled,
Name = name,
QueryCkId = ckId,
FieldFilter = JsonConvert.SerializeObject(fieldFilters),
ServiceHookBaseUri = serviceHookBaseUri,
ServiceHookAction = serviceHookAction
};
var query = new GraphQLRequest
{
Query = GraphQl.CreateServiceHook,
Variables = new { entities = new[] { createServiceHookDto } }
};
var result = await ServiceClient.SendMutationAsync <IEnumerable <RtServiceHookDto> >(query);
Logger.Info($"Service hook '{name}' added (ID '{result.First().RtId}').");
}
protected override void AddArguments()
{
_clientId = CommandArgumentValue.AddArgument("id", "clientId", new[] { "ServiceClient ID, must be unique" }, true,
1);
_clientName = CommandArgumentValue.AddArgument("n", "name", new[] { "Display name of client used for grants" }, true,
1);
_clientSecret = CommandArgumentValue.AddArgument("s", "secret", new[] { "Secret that is used for client credential authentication" }, true,
1);
}
protected override void AddArguments()
{
_alias = CommandArgumentValue.AddArgument("a", "alias", new[] { "Alias of identity provider, must be unique" }, true,
1);
_enabled = CommandArgumentValue.AddArgument("e", "enabled", new[] { "True if identity provider should be enabled, otherwise false" }, true,
1);
_clientId = CommandArgumentValue.AddArgument("cid", "clientId", new[] { "ServiceClient ID, provided by provider" }, true, 1);
_clientSecret = CommandArgumentValue.AddArgument("cs", "clientSecret", new[] { "ServiceClient secret, provided by provider" }, true, 1);
_type = CommandArgumentValue.AddArgument("t", "type", new[] { "Type of provider, available is 'google' or 'microsoft'" }, true, 1);
}
public override async Task Execute()
{
var nameArgData = CommandArgumentValue.GetArgumentValue(_nameArg);
var name = nameArgData.GetValue <string>().ToLower();
Logger.Info($"Deleting user '{name}' at '{ServiceClient.ServiceUri}'");
await ServiceClient.DeleteUser(name);
Logger.Info($"User '{name}' deleted.");
}
protected override void AddArguments()
{
_eMailArg = CommandArgumentValue.AddArgument("e", "eMail", new[] { "E-Mail of user" },
false, 1);
_nameArg = CommandArgumentValue.AddArgument("un", "userName", new[] { "User name" }, true,
1);
_newNameArg = CommandArgumentValue.AddArgument("nun", "newUserName", new[] { "New user name, if the user name has to be changed" }, false,
1);
_roleArg = CommandArgumentValue.AddArgument("r", "role", new[] { "Role of user" }, false,
1);
}
protected override void AddArguments()
{
_id = CommandArgumentValue.AddArgument("id", "identifier", new[] { "ID of identity provider, must be unique" }, true,
1);
_alias = CommandArgumentValue.AddArgument("a", "alias", new[] { "Alias of identity provider, must be unique" }, true,
1);
_enabled = CommandArgumentValue.AddArgument("e", "enabled", new[] { "True if identity provider should be enabled, otherwise false" }, true,
1);
_clientId = CommandArgumentValue.AddArgument("cid", "clientId", new[] { "ServiceClient ID, provided by provider" }, true, 1);
_clientSecret = CommandArgumentValue.AddArgument("cs", "clientSecret", new[] { "ServiceClient secret, provided by provider" }, true, 1);
}
protected override void AddArguments()
{
_coreServicesUriArg = CommandArgumentValue.AddArgument("csu", "coreServicesUri",
new[] { "URI of core services (e. g. 'https://localhost:5001/')" }, 1);
_jobServicesUriArg = CommandArgumentValue.AddArgument("jsu", "jobServicesUri",
new[] { "URI of job services (e. g. 'https://localhost:5009/')" }, 1);
_identityServicesUriArg = CommandArgumentValue.AddArgument("isu", "identityServicesUri",
new[] { "URI of identity services (e. g. 'https://localhost:5003/')" }, 1);
_tenantIdArg = CommandArgumentValue.AddArgument("tid", "tenantId",
new[] { "Id of tenant (e. g. 'myService')" }, 1);
}
public override async Task Execute()
{
var id = CommandArgumentValue.GetArgumentScalarValue <string>(_id);
Logger.Info($"Deleting identity provider '{id}' from '{ServiceClient.ServiceUri}'");
await ServiceClient.DeleteIdentityProvider(id);
Logger.Info($"Identity provider '{id}' deleted.");
}
public override async Task Execute()
{
var tenantIdArgData = CommandArgumentValue.GetArgumentValue(_tenantIdArg);
var tenantId = tenantIdArgData.GetValue <string>().ToLower();
Logger.Info($"Clearing cache tenant '{tenantId}' on at '{ServiceClient.ServiceUri}'");
await ServiceClient.ClearTenantCache(tenantId);
Logger.Info($"Tenant cache '{tenantId}' on at '{ServiceClient.ServiceUri}' cleared.");
}
public override async Task Execute()
{
var tenantIdArgData = CommandArgumentValue.GetArgumentValue(_tenantIdArg);
var tenantId = tenantIdArgData.GetValue <string>().ToLower();
Logger.Info($"Detach tenant '{tenantId}' at '{ServiceClient.ServiceUri}'");
await ServiceClient.DetachTenant(tenantId);
Logger.Info($"Tenant '{tenantId}' at '{ServiceClient.ServiceUri}' detached.");
}
public override async Task Execute()
{
var clientIdArgData = CommandArgumentValue.GetArgumentValue(_clientId);
var clientId = clientIdArgData.GetValue <string>();
Logger.Info($"Deleting client '{clientId}' from '{ServiceClient.ServiceUri}'");
await ServiceClient.DeleteClient(clientId);
Logger.Info($"ServiceClient '{clientId}' deleted.");
}
public override async Task Execute()
{
Logger.Info("Adding admin");
var eMail = CommandArgumentValue.GetArgumentScalarValue <string>(_eMailArg);
var password = CommandArgumentValue.GetArgumentScalarValue <string>(_passwordArg);
await _identityServicesSetupClient.AddAdminUser(new AdminUserDto
{
EMail = eMail,
Password = password
});
}
public override async Task Execute()
{
var serviceHookId = CommandArgumentValue.GetArgumentScalarValue <string>(_serviceHookIdArg);
Logger.Info($"Deleting service hook '{serviceHookId}' at '{_tenantClient.ServiceUri}'");
var getQuery = new GraphQLRequest
{
Query = GraphQl.GetServiceHookDetails,
Variables = new
{
rtId = serviceHookId
}
};
var getResult = await _tenantClient.SendQueryAsync <RtServiceHookDto>(getQuery);
if (!getResult.Items.Any())
{
throw new InvalidOperationException(
$"Service Hook with ID '{serviceHookId}' does not exist.");
}
var serviceHookDto = getResult.Items.First();
var deleteMutation = new GraphQLRequest
{
Query = GraphQl.DeleteServiceHook,
Variables = new
{
entities = new[]
{
new MutationDto
{
RtId = serviceHookDto.RtId
}
}
}
};
var result = await _tenantClient.SendMutationAsync <bool>(deleteMutation);
if (result)
{
Logger.Info($"Service hook '{serviceHookId}' deleted.");
}
else
{
Logger.Error($"Service hook '{serviceHookId}' delete failed.");
}
}
public override async Task Execute()
{
var nameArgData = CommandArgumentValue.GetArgumentValue(_nameArg);
var name = nameArgData.GetValue <string>().ToLower();
var passwordArgData = CommandArgumentValue.GetArgumentValue(_passwordArg);
var password = passwordArgData.GetValue <string>();
Logger.Info($"Resetting password for user '{name}' at '{ServiceClient.ServiceUri}'");
await ServiceClient.ResetPassword(name, password);
Logger.Info($"Resetting password for user '{name}' done.");
}
public override async Task Execute()
{
var tenantIdArgData = CommandArgumentValue.GetArgumentValue(_tenantIdArg);
var tenantId = tenantIdArgData.GetValue <string>().ToLower();
var databaseArgData = CommandArgumentValue.GetArgumentValue(_databaseArg);
var databaseName = databaseArgData.GetValue <string>().ToLower();
Logger.Info($"Creating tenant '{tenantId}' (database '{databaseName}') at '{ServiceClient.ServiceUri}'");
await ServiceClient.CreateTenant(tenantId, databaseName);
Logger.Info($"Tenant '{tenantId}' (database '{databaseName}') at '{ServiceClient.ServiceUri}' created.");
}
public override async Task Execute()
{
bool isInteractive = CommandArgumentValue.IsArgumentUsed(_interactiveArg);
Logger.Info($"Device log-in at '{Options.Value.IdentityServiceUrl}' in progress...");
var response = await _authenticatorClient.RequestDeviceAuthorizationAsync(
CommonConstants.ApiScopes.IdentityApiFullAccess | CommonConstants.ApiScopes.SystemApiFullAccess |
CommonConstants.ApiScopes.JobApiFullAccess);
Logger.Info($"Device Code: {response.DeviceCode}");
Logger.Info($"Estimated code expiration at: {response.ExpiresAt}");
Logger.Info("");
Logger.Info("");
Logger.Info($"Using a browser, visit:");
Logger.Info($"{response.VerificationUri}");
Logger.Info($"Enter the code:");
Logger.Info($"{response.UserCode}");
if (isInteractive)
{
Logger.Info($"Opening default browser...");
Process.Start(new ProcessStartInfo(response.VerificationUriComplete)
{
UseShellExecute = true
});
}
while (true)
{
Logger.Info("Waiting for device authentication...");
Thread.Sleep(response.PollingInterval * 1000);
var authenticationData = await _authenticatorClient.RequestDeviceTokenAsync(response.DeviceCode);
if (authenticationData.IsAuthenticationPending)
{
Thread.Sleep(response.PollingInterval * 1000);
continue;
}
_authenticationService.SaveAuthenticationData(authenticationData);
Logger.Info($"Device log-in successful. Token expires at '{authenticationData.ExpiresAt}'.");
break;
}
}
public override async Task Execute()
{
Logger.Info(
$"Resetting notification messages at '{Options.Value.CoreServiceUrl}' for tenant '{Options.Value.TenantId}'");
var type = CommandArgumentValue.GetArgumentScalarValue <NotificationTypesDto>(_type);
var filterList = new List <FieldFilterDto>
{
new FieldFilterDto
{
AttributeName = nameof(NotificationMessageDto.SendStatus),
Operator = FieldFilterOperatorDto.Equals,
ComparisonValue = SendStatusDto.Error
},
new FieldFilterDto
{
AttributeName = nameof(NotificationMessageDto.NotificationType),
Operator = FieldFilterOperatorDto.Equals,
ComparisonValue = type
}
};
var getQuery = new GraphQLRequest
{
Query = GraphQl.GetNotifications,
Variables = new { fieldFilters = filterList.ToArray() }
};
var getResult = await _tenantClient.SendQueryAsync <NotificationMessageDto>(getQuery);
if (!getResult.Items.Any())
{
Logger.Info($"No notifications in error has been returned.");
return;
}
Logger.Info($"{getResult.Items.Count()} notification messages in error has been returned.");
foreach (var notificationMessageDto in getResult.Items)
{
notificationMessageDto.LastTryDateTime = DateTime.UtcNow.AddMinutes(-10);
notificationMessageDto.SendStatus = SendStatusDto.Pending;
}
await _notificationRepository.StoreNotificationMessages(Options.Value.TenantId, getResult.Items);
Logger.Info($"Reset notficiation messages completed.");
}
public override async Task Execute()
{
var fileArgData = CommandArgumentValue.GetArgumentValue(_fileArg);
var rtModelFilePath = fileArgData.GetValue <string>().ToLower();
var tenantId = Options.Value.TenantId;
if (string.IsNullOrWhiteSpace(tenantId))
{
throw new ServiceConfigurationMissingException("Tenant is missing.");
}
Logger.Info("Importing runtime model '{0}'", rtModelFilePath);
var id = await _coreServicesClient.ImportRtModel(tenantId, rtModelFilePath);
Logger.Info($"Runtime model import id '{id}' has been started.");
await WaitForJob(id);
}
