public bool HostDomainIsAuthorized()
{
IRequest request = HttpContext?.Request;
string host = request.Url?.Host;
int port = (request?.Url?.Port).Value;
Bam.Net.CoreServices.ApplicationRegistration.Data.Application app = GetServerApplicationOrDie();
if (app.HostDomains.Count > 0)
{
HostDomain hd = app.HostDomains.Where(h => h.DomainName.Equals(host) && h.Port.Equals(port)).FirstOrDefault();
return(hd == null ? false : hd.Authorized);
}
else
{
HostDomain hd = new HostDomain
{
Authorized = true,
DomainName = host,
DefaultApplicationName = app.Name,
Port = port
};
app.HostDomains.Add(hd);
Task.Run(() => ApplicationRegistrationRepository.Save(app));
return(true);
}
}
private CoreConfigurationService GetTestCoreConfigurationService(string testName)
{
string appName = $"{testName}_TestAppName";
string userDbPath = $".\\{testName}_Test";
string configurationName = $"{testName}_TestConfigName";
string testUserName = $"{testName}_TestUserName";
Database userDb = new SQLiteDatabase(testName);
ApplicationRegistrationRepository coreRepo = new ApplicationRegistrationRepository();
coreRepo.Database = new SQLiteDatabase($"{testName}_coredb");
userDb.TryEnsureSchema <UserAccounts.Data.User>();
Db.For <UserAccounts.Data.User>(userDb);
CoreConfigurationService configSvc = new CoreConfigurationService(coreRepo, new Server.AppConf(), userDbPath);
configSvc.DaoRepository = coreRepo;
IApplicationNameProvider appNameProvider = Substitute.For <IApplicationNameProvider>();
appNameProvider.GetApplicationName().Returns(appName);
configSvc.ApplicationNameProvider = appNameProvider;
IUserManager userMgr = Substitute.For <IUserManager>();
UserAccounts.Data.User testUser = new UserAccounts.Data.User();
testUser.UserName = testUserName;
userMgr.GetUser(Arg.Any <IHttpContext>()).Returns(testUser);
configSvc.UserManager = userMgr;
return(configSvc);
}
public void SavingMachineSavesNicsAndHostAddresses()
{
Machine machine = new Machine();
Database db = new SQLiteDatabase($".\\{nameof(SavingMachineSavesNicsAndHostAddresses)}", "CoreRegistryRepository");
db.TryEnsureSchema <ApplicationRegistration.Dao.Nic>();
ApplicationRegistrationRepository repo = new ApplicationRegistrationRepository()
{
Database = db
};
ApplicationRegistration.Dao.Nic.LoadAll(repo.Database).Delete(repo.Database);
ApplicationRegistration.Dao.HostAddress.LoadAll(repo.Database).Delete(repo.Database);
ApplicationRegistration.Dao.Machine.LoadAll(repo.Database).Delete(repo.Database);
machine = machine.Save(repo) as Machine;
machine.NetworkInterfaces.Each(n => OutLine(n.PropertiesToString(), ConsoleColor.Cyan));
machine.HostAddresses.Each(h => OutLine(h.PropertiesToString(), ConsoleColor.Blue));
ApplicationRegistration.Dao.NicCollection nics = ApplicationRegistration.Dao.Nic.LoadAll(repo.Database);
ApplicationRegistration.Dao.HostAddressCollection hosts = ApplicationRegistration.Dao.HostAddress.LoadAll(repo.Database);
Machine machineAgain = machine.Save(repo) as Machine;
Expect.AreEqual(machine.Id, machineAgain.Id, "Id didn't match");
Expect.AreEqual(machine.Uuid, machineAgain.Uuid, "Uuid didn't match");
Expect.AreEqual(machine.Cuid, machineAgain.Cuid, "Cuid didn't match");
ApplicationRegistration.Dao.NicCollection nicsAgain = ApplicationRegistration.Dao.Nic.LoadAll(repo.Database);
ApplicationRegistration.Dao.HostAddressCollection hostsAgain = ApplicationRegistration.Dao.HostAddress.LoadAll(repo.Database);
Expect.AreEqual(nics.Count, nicsAgain.Count, "Nic count didn't match");
Expect.AreEqual(hosts.Count, hostsAgain.Count, "Host address count didn't match");
}
public void EnsureSingleDoesntDuplicate()
{
ServiceRegistry glooRegistry = CoreServiceRegistryContainer.GetServiceRegistry();
ApplicationRegistrationRepository repo = glooRegistry.Get <ApplicationRegistrationRepository>();
CompositeRepository compositeRepo = glooRegistry.Get <CompositeRepository>();
compositeRepo.UnwireBackup();
Machine machine = Machine.Current;
repo.Delete(machine);
Machine retrieved = repo.Query <Machine>(Filter.Where("Name") == machine.Name && Filter.Where("Cuid") == machine.Cuid).FirstOrDefault();
Expect.IsNull(retrieved);
Machine ensured = machine.EnsureSingle <Machine>(repo, "Name", "Cuid");
Expect.IsNotNull(ensured, "Ensured was null");
Machine ensuredAgain = ensured.EnsureSingle <Machine>(repo, "Name", "Cuid");
Expect.AreEqual(ensured.Id, ensuredAgain.Id);
Expect.AreEqual(ensured.Uuid, ensuredAgain.Uuid);
Expect.AreEqual(ensured.Cuid, ensuredAgain.Cuid);
Expect.AreEqual(1, repo.Query <Machine>(new { Name = machine.Name, Cuid = machine.Cuid }).Count());
repo.Delete(machine);
}
public static Client Of(ApplicationRegistrationRepository repo, string applicationName, string serverHost, int serverPort)
{
Machine persistedCurrent = repo.OneMachineWhere(m => m.Name == Machine.Current.Name);
if (persistedCurrent == null)
{
persistedCurrent = repo.Save(Machine.Current);
}
Application app = repo.GetOneApplicationWhere(a => a.Name == applicationName);
Client result = repo.OneClientWhere(c =>
c.MachineId == persistedCurrent.Id &&
c.MachineName == persistedCurrent.Name &&
c.ApplicationId == app.Id &&
c.ApplicationName == app.Name &&
c.ServerHost == serverHost &&
c.Port == serverPort);
if (result == null)
{
result = new Client
{
MachineId = persistedCurrent.Id,
MachineName = persistedCurrent.Name,
ApplicationId = app.Id,
ApplicationName = app.Name,
ServerHost = serverHost,
Port = serverPort
};
result = repo.Save(result);
}
return(result);
}
public CoreServiceResponse <CoreServices.ApplicationRegistration.Data.Application> CreateApplication(string applicationName)
{
Organization org = User.Organizations.Where(o => o.Name.Equals(OrganizationName)).FirstOrDefault();
CoreServices.ApplicationRegistration.Data.Application app = ApplicationRegistrationRepository.OneApplicationWhere(c => c.Name == applicationName && c.OrganizationId == org.Id);
if (app == null)
{
app = new CoreServices.ApplicationRegistration.Data.Application {
Name = applicationName, OrganizationId = org.Id
};
app = ApplicationRegistrationRepository.Save(app);
ProcessDescriptor instance = new ProcessDescriptor {
InstanceIdentifier = $"{ClientIpAddress}-{app.Name}-{app.Cuid}"
};
app.Instances.Add(instance);
app.Machines.Add(new Machine {
Name = HostName
});
app = CoreApplicationRegistryService.AddApiKey(ApplicationRegistrationRepository, app);
return(new CoreServiceResponse <ApplicationRegistration.Data.Application>(app)
{
Success = true, Message = $"Application {applicationName} created"
});
}
else
{
return(new CoreServiceResponse <ApplicationRegistration.Data.Application>(app)
{
Success = true, Message = $"Application {applicationName} already registered for the organization {OrganizationName}"
});
}
}
private void SetLocalProperties(string organizationName, string applicationName, string hostName, int port)
{
LocalCoreRegistryRepository = new ApplicationRegistrationRepository();
LocalCoreRegistryRepository.Database = new SQLiteDatabase(WorkspaceDirectory, nameof(CoreClient));
CoreServiceRegistryContainer.GetServiceRegistry().Get <IStorableTypesProvider>().AddTypes(LocalCoreRegistryRepository);
ProcessDescriptor = ProcessDescriptor.ForApplicationRegistration(LocalCoreRegistryRepository, hostName, port, applicationName, organizationName);
}
public virtual string GetApplicationApiKey(string applicationClientId, int index)
{
CoreServices.ApplicationRegistration.Data.Application app = ApplicationRegistrationRepository.OneApplicationWhere(c => c.Cuid == applicationClientId);
if (app != null)
{
return(app.ApiKeys[index]?.SharedSecret);
}
return(string.Empty);
}
public void CanSaveMachineInCoreRegistryRepo()
{
ApplicationRegistrationRepository repo = CoreServiceRegistryContainer.GetServiceRegistry().Get<ApplicationRegistrationRepository>();
Client test = Client.Of(repo, "test", "test", 80);//Machine.ClientOf(repo, "test", 80);
test = repo.Save(test);
Expect.IsTrue(test.Id > 0);
Client test2 = Client.Of(repo, "test", "test", 80);//Machine.ClientOf(repo, "test", 90);
test2 = repo.Save(test2);
Expect.IsTrue(test2.Id > 0);
}
protected internal Bam.Net.CoreServices.ApplicationRegistration.Data.Application GetServerApplicationOrDie()
{
Bam.Net.CoreServices.ApplicationRegistration.Data.Application app = ApplicationRegistrationRepository.GetOneApplicationWhere(c => c.Name == ServerApplicationName);
if (app.Equals(ApplicationRegistration.Data.Application.Unknown))
{
throw new InvalidOperationException("Application is Uknown");
}
return(app);
}
public virtual void SetCommonConfiguration(Dictionary <string, string> settings)
{
lock (_commonLock)
{
ApplicationRegistration.Data.Configuration config = ApplicationRegistrationRepository.GetOneConfigurationWhere(c => c.Name == CommonConfigName && c.ApplicationId == Application.Unknown.Id);
config.Settings.Each(s => ApplicationRegistrationRepository.Delete(s));
config.Settings = DictionaryToSettings(settings, config).ToList();
ApplicationRegistrationRepository.Save(config);
}
}
protected internal ApplicationRegistration.Application AddApiKey(ApplicationRegistrationRepository repo, ApplicationRegistration.Application app, out ApplicationRegistration.ApiKey key)
{
ApiKeyInfo keyInfo = GenerateApiKeyInfo(app);
key = ApplicationRegistration.ApiKey.FromKeyInfo(keyInfo);
key.Created = DateTime.UtcNow;
key.CreatedBy = CurrentUser.UserName;
app.ApiKeys.Add(key);
app = repo.Save(app);
return(app);
}
public virtual int GetActiveApiKeyIndex(IApplicationNameProvider nameProvider)
{
string clientId = GetApplicationClientId(nameProvider);
ActiveApiKeyIndex apiKeyIndex = ApplicationRegistrationRepository.OneActiveApiKeyIndexWhere(c => c.ApplicationCuid == clientId);
if (apiKeyIndex != null)
{
return(apiKeyIndex.Value);
}
return(0);
}
public virtual Dictionary <string, string> GetMachineConfiguration(string machineName, string configurationName = null)
{
configurationName = configurationName ?? CommonConfigName;
Machine machine = ApplicationRegistrationRepository.GetOneMachineWhere(c => c.Name == machineName);
ApplicationRegistration.Data.Configuration config = machine.Configurations.FirstOrDefault(c => c.Name.Equals(configurationName));
if (config != null)
{
return(SettingsToDictionary(config.Settings));
}
return(new Dictionary <string, string>());
}
public CoreApplicationRegistrationService(CoreApplicationRegistryServiceConfig config, AppConf conf, ApplicationRegistrationRepository coreRepo, ILogger logger)
{
CoreRegistryRepository = coreRepo;
CoreRegistryRepository.WarningsAsErrors = false;
config.DatabaseProvider.SetDatabases(this);
CompositeRepository = new CompositeRepository(CoreRegistryRepository, config.WorkspacePath);
_cacheManager = new CacheManager(100000000);
_apiKeyResolver = new ApiKeyResolver(this, this);
AppConf = conf;
Config = config;
Logger = logger;
HashAlgorithm = HashAlgorithms.SHA256;
}
public ApplicationRegistrationService(DataSettings dataSettings, AppConf conf, ApplicationRegistrationRepository coreRepo, ILogger logger)
{
ApplicationRegistrationRepository = coreRepo;
ApplicationRegistrationRepository.WarningsAsErrors = false;
dataSettings.SetDatabases(this);
CompositeRepository = new CompositeRepository(ApplicationRegistrationRepository, dataSettings);
_cacheManager = new CacheManager(100000000);
_apiKeyResolver = new ApiKeyResolver(this, this);
AppConf = conf;
DataSettings = dataSettings;
Logger = logger;
HashAlgorithm = HashAlgorithms.SHA256;
}
public void CoreClientCanRegisterAndConnectClient()
{
Message.PrintLine("This test requires a gloo server to be running on port 9100 of the localhost", ConsoleColor.Yellow);
ApplicationRegistrationRepository repo = CoreServiceRegistryContainer.GetServiceRegistry().Get<ApplicationRegistrationRepository>();
ConsoleLogger logger = new ConsoleLogger() { AddDetails = false };
logger.StartLoggingThread();
CoreClient client = new CoreClient("Bam.Net", "CoreServicesTestApp", "localhost", 9100, logger);
client.LocalCoreRegistryRepository = repo;
CoreServiceResponse registrationResponse = client.RegisterClient();
Expect.IsTrue(registrationResponse.Success, registrationResponse.Message);
CoreServiceResponse response = client.Connect();
List<CoreServiceResponse> responses = response.Data.FromJObject<List<CoreServiceResponse>>();
Expect.IsTrue(response.Success, string.Join("\r\n", responses.Select(r => r.Message).ToArray()));
}
public virtual Dictionary <string, string> GetApplicationConfiguration(string applicationName = null, string configurationName = null)
{
applicationName = applicationName ?? ApplicationName;
ValidAppOrDie(applicationName);
configurationName = configurationName ?? CommonConfigName;
Application application = ApplicationRegistrationRepository.GetOneApplicationWhere(c => c.Name == applicationName);
ApplicationRegistration.Data.Configuration config = application.Configurations.FirstOrDefault(c => c.Name.Equals(configurationName));
if (config != null)
{
return(SettingsToDictionary(config.Settings));
}
return(new Dictionary <string, string>());
}
public bool UserIsInOrganization(string organizationName)
{
if (organizationName.Equals(Organization.Public.Name))
{
return(true);
}
User user = GetApplicationUserOrDie();
Organization org = ApplicationRegistrationRepository.OneOrganizationWhere(c => c.Name == organizationName);
if (org != null)
{
return(org.Users.Contains(user));
}
return(false);
}
private User GetApplicationRegistrationRepositoryUser()
{
User user = ApplicationRegistrationRepository.OneUserWhere(c => c.UserName == CurrentUser.UserName);
if (user == null)
{
user = new User()
{
UserName = CurrentUser.UserName,
Email = CurrentUser.Email
};
user = ApplicationRegistrationRepository.Save(user);
}
return(user);
}
public static ProcessDescriptor ForApplicationRegistration(ApplicationRegistrationRepository repo, string serverHost, int port, string applicationName, string organizationName = null)
{
Args.ThrowIfNull(repo, nameof(repo));
Args.ThrowIfNullOrEmpty(serverHost, nameof(serverHost));
Args.ThrowIfNullOrEmpty(applicationName, nameof(applicationName));
ProcessDescriptor result = new ProcessDescriptor();
result.CopyProperties(Current);
result.LocalClient = repo.GetOneClientWhere(m => m.MachineName == Machine.Current.Name && m.ApplicationName == Machine.Current.DnsName && m.ServerHost == serverHost && m.Port == port);
result.Application = new Application {
Name = applicationName, Organization = new Organization {
Name = organizationName.Or(Organization.Public.Name)
}
};
return(result);
}
public void RegisterCreatesMachineEntry()
{
OutLineFormat("This test requires a gloo server to be running on port 9100 of the localhost", ConsoleColor.Yellow);
ConsoleLogger logger = new ConsoleLogger();
logger.AddDetails = false;
logger.StartLoggingThread();
ApplicationRegistrationRepository repo = CoreServiceRegistryContainer.GetServiceRegistry().Get <ApplicationRegistrationRepository>();
CoreClient client = new CoreClient("TestOrg", "TestApp", $".\\{nameof(RegisterCreatesMachineEntry)}", logger);
client.LocalCoreRegistryRepository = repo;
CoreServiceResponse registrationResponse = client.RegisterClient();
Machine machine = repo.OneMachineWhere(m => m.Name == Machine.Current.Name);
Expect.IsNotNull(machine);
Pass(nameof(RegisterCreatesMachineEntry));
}
public string ResolveApplicationName(IHttpContext context)
{
string fromHeader = context?.Request?.Headers[CustomHeaders.ApplicationName];
if (string.IsNullOrEmpty(fromHeader))
{
string domainName = context?.Request?.Url?.Host;
if (!string.IsNullOrEmpty(domainName))
{
HostDomain hostDomain = ApplicationRegistrationRepository.OneHostDomainWhere(d => d.DomainName == domainName);
if (hostDomain != null)
{
return(hostDomain.DefaultApplicationName);
}
}
}
return(fromHeader.Or(Bam.Net.CoreServices.ApplicationRegistration.Data.Application.Unknown.Name));
}
public void ApplicationRegistryRepositoryGetOneUserShouldHaveNoOrganization()
{
TimeSpan elapsed = Timed.Execution(() =>
{
ApplicationRegistrationRepository repo = new ApplicationRegistrationRepository();
repo.Database = new SQLiteDatabase($"{nameof(ApplicationRegistryRepositoryGetOneUserShouldHaveNoOrganization)}", nameof(ApplicationRegistryRepositoryGetOneUserShouldHaveNoOrganization));
var user = repo.GetOneUserWhere(c => c.UserName == "bryan");
Expect.IsNotNull(user);
Expect.AreEqual(0, user.Organizations.Count);
Expect.IsGreaterThan(user.Id, 0);
OutLine(user.PropertiesToString(), ConsoleColor.Cyan);
repo.Delete(user);
user = repo.Retrieve <ApplicationRegistration.User>(user.Id);
Expect.IsNull(user);
});
OutLine(elapsed.ToString(), ConsoleColor.Cyan);
}
private ConfigurationService GetTestCoreConfigurationService(string testName)
{
string appName = $"{testName}_TestAppName";
string userDbPath = $".\\{testName}_Test";
string configurationName = $"{testName}_TestConfigName";
string testUserName = $"{testName}_TestUserName";
Database userDb = new SQLiteDatabase(testName);
ApplicationRegistrationRepository coreRepo = new ApplicationRegistrationRepository();
coreRepo.Database = new SQLiteDatabase($"{testName}_coredb");
userDb.TryEnsureSchema <UserAccounts.Data.User>();
Db.For <UserAccounts.Data.User>(userDb);
ConfigurationService configSvc = new ConfigurationService(coreRepo, new Server.AppConf(), userDbPath);
configSvc.DaoRepository = coreRepo;
IApplicationNameProvider appNameProvider = Substitute.For <IApplicationNameProvider>();
appNameProvider.GetApplicationName().Returns(appName);
configSvc.ApplicationNameProvider = appNameProvider;
IUserManager userMgr = Substitute.For <IUserManager>();
UserAccounts.Data.User testUser = new UserAccounts.Data.User()
{
UserName = testUserName
};
userMgr.GetUser(Arg.Any <IHttpContext>()).Returns(testUser);
configSvc.UserManager = userMgr;
IHttpContext ctx = Substitute.For <IHttpContext>();
ctx.Request = Substitute.For <IRequest>();
NameValueCollection headers = new NameValueCollection
{
[CustomHeaders.ApplicationName] = testName
};
ctx.Request.Headers.Returns(headers);
ctx.Request.Cookies.Returns(new System.Net.CookieCollection());
ctx.Response = Substitute.For <IResponse>();
ctx.Response.Cookies.Returns(new System.Net.CookieCollection());
configSvc.HttpContext = ctx;
return(configSvc);
}
public void WhoAmITest()
{
//OutLineFormat("This test requires a gloo server to be running on port 9100 of the localhost", ConsoleColor.Yellow);
ConsoleLogger logger = new ConsoleLogger()
{
AddDetails = false
};
const string server = "localhost";// "int-heart.bamapps.net";
const int port = 80;
logger.StartLoggingThread();
ApplicationRegistrationRepository repo = ApplicationServiceRegistryContainer.GetServiceRegistry().Get <ApplicationRegistrationRepository>();
CoreClient client = new CoreClient("TestOrg", "TestApp", server, port, logger)
{
UseServiceSubdomains = false,
LocalCoreRegistryRepository = repo
};
client.InvocationException += (o, args) => logger.AddEntry("Invocation Exception: {0}", ((ServiceProxyInvokeEventArgs)args).Exception, args.PropertiesToString());
client.MethodInvoked += (o, args) => logger.AddEntry("ProxyClient Method Invoked: {0}", args.PropertiesToString());
CoreServiceResponse registrationResponse = client.RegisterClient();
Client current = Client.Of(client.LocalCoreRegistryRepository, client.ApplicationName, server, port);
CoreServiceResponse response = client.Connect();
string whoAmI = client.UserRegistryService.WhoAmI();
Expect.AreEqual(current.ToString(), whoAmI);
whoAmI = client.ApplicationRegistryService.WhoAmI();
Expect.AreEqual(current.ToString(), whoAmI);
whoAmI = client.ConfigurationService.WhoAmI();
Expect.AreEqual(current.ToString(), whoAmI);
whoAmI = client.LoggerService.WhoAmI();
Expect.AreEqual(current.ToString(), whoAmI);
whoAmI = client.DiagnosticService.WhoAmI();
Expect.AreEqual(current.ToString(), whoAmI);
Pass($"You are {whoAmI}");
}
public virtual void SetMachineConfiguration(string machineName, Dictionary <string, string> settings, string configurationName = null)
{
configurationName = configurationName ?? CommonConfigName;
Machine machine = ApplicationRegistrationRepository.GetOneMachineWhere(c => c.Name == machineName);
lock (Machine.ConfigurationLock)
{
ApplicationRegistration.Data.Configuration config = machine.Configurations.FirstOrDefault(c => c.Name.Equals(configurationName));
if (config == null)
{
config = new ApplicationRegistration.Data.Configuration {
Name = configurationName
};
config.MachineId = machine.Id;
config = ApplicationRegistrationRepository.Save(config);
}
config.Settings = DictionaryToSettings(settings, config).ToList();
ApplicationRegistrationRepository.Save(config);
}
}
private CatalogService GetTestCatalogService(string databaseName, out DaoRepository daoRepository)
{
Database testDatabase = DataProvider.Current.GetAppDatabase(databaseName);
Log.Default = new ConsoleLogger();
daoRepository = new DaoRepository(testDatabase, Log.Default);
IRepository catalogRepo = daoRepository;
ApplicationRegistrationRepository applicationRegistrationRepository = new ApplicationRegistrationRepository();
AsyncCallbackService asyncCallbackService = Substitute.For <AsyncCallbackService>();
CatalogService svc = new CatalogService(catalogRepo, asyncCallbackService, daoRepository, new AppConf())
{
ApplicationRegistrationRepository = applicationRegistrationRepository
};
daoRepository.DeleteAll <CatalogDefinition>();
daoRepository.DeleteAll <CatalogItem>();
daoRepository.DeleteAll <ItemDefinition>();
daoRepository.DeleteAll <ItemOption>();
daoRepository.DeleteAll <ItemProperty>();
return(svc);
}
public CoreServiceResponse GetClientSettings()
{
try
{
ApplicationRegistration.Data.Application app = ApplicationRegistrationRepository.GetOneApplicationWhere(c => c.Name == base.ApplicationName);
return(new CoreServiceResponse
(
OAuthSettingsRepository
.OAuthSettingsDatasWhere(c => c.ApplicationIdentifier == app.Cuid && c.ApplicationName == app.Name)
.Select(sd => OAuthSettings.FromData(sd))
.Select(os => os.CopyAs <OAuthClientSettings>())
.ToArray()
));
}
catch (Exception ex)
{
return(new CoreServiceResponse {
Success = false, Message = ex.Message
});
}
}
public virtual void SetApplicationConfiguration(Dictionary <string, string> settings, string applicationName = null, string configurationName = null)
{
applicationName = applicationName ?? ApplicationName;
ValidAppOrDie(applicationName);
configurationName = configurationName ?? CommonConfigName;
Application application = ApplicationRegistrationRepository.GetOneApplicationWhere(c => c.Name == applicationName);
lock (Application.ConfigurationLock)
{
ApplicationRegistration.Data.Configuration config = application.Configurations.FirstOrDefault(c => c.Name.Equals(configurationName));
if (config == null)
{
config = new ApplicationRegistration.Data.Configuration {
Name = configurationName
};
config.ApplicationId = application.Id;
config = ApplicationRegistrationRepository.Save(config);
}
config.Settings = DictionaryToSettings(settings, config).ToList();
ApplicationRegistrationRepository.Save(config);
}
}
