nhyatt/bitwarden
1
0
Fork 0
mirror of https://github.com/bitwarden/server.git synced 2025-04-05 05:00:19 -05:00
Code

deleted backup files

Browse Source
This commit is contained in:
Robert Y 2025-03-13 16:51:40 -06:00
parent 7877042c32
commit 44f4efffaf
15 changed files with 342 additions and 759 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

206
util/seeder/Commands/ExtractCommand.cs
View File

@ -1,119 +1,117 @@
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Bit.Core.Enums;
using Bit.Seeder.Services;
using Bit.Seeder.Settings;
using Microsoft.AspNetCore.DataProtection;
using Bit.Core;
using Microsoft.Extensions.Configuration;
using Microsoft.EntityFrameworkCore;
using Bit.Core.Enums;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
namespace Bit.Seeder.Commands
namespace Bit.Seeder.Commands;
public class ExtractCommand
{
public class ExtractCommand
public bool Execute(string seedName)
{
public bool Execute(string seedName)
try
{
try
{
// Create service provider with necessary services
var services = new ServiceCollection();
ConfigureServices(services);
var serviceProvider = services.BuildServiceProvider();
// Create service provider with necessary services
var services = new ServiceCollection();
ConfigureServices(services);
var serviceProvider = services.BuildServiceProvider();
// Get the necessary services
var seederService = serviceProvider.GetRequiredService<ISeederService>();
var logger = serviceProvider.GetRequiredService<ILogger<ExtractCommand>>();
// Get the necessary services
var seederService = serviceProvider.GetRequiredService<ISeederService>();
var logger = serviceProvider.GetRequiredService<ILogger<ExtractCommand>>();
logger.LogInformation($"Extracting data from database to seed: {seedName}");
// Execute the extract operation
seederService.ExtractSeedsAsync(seedName).GetAwaiter().GetResult();
logger.LogInformation("Seed extraction completed successfully");
return true;
}
catch (Exception ex)
{
Console.WriteLine($"Error extracting seeds: {ex.Message}");
if (ex.InnerException != null)
{
Console.WriteLine($"Inner exception: {ex.InnerException.Message}");
}
Console.WriteLine($"Stack trace: {ex.StackTrace}");
return false;
}
logger.LogInformation($"Extracting data from database to seed: {seedName}");
// Execute the extract operation
seederService.ExtractSeedsAsync(seedName).GetAwaiter().GetResult();
logger.LogInformation("Seed extraction completed successfully");
return true;
}
private void ConfigureServices(ServiceCollection services)
catch (Exception ex)
{
// Add logging
services.AddLogging(builder =>
Console.WriteLine($"Error extracting seeds: {ex.Message}");
if (ex.InnerException != null)
{
builder.AddConsole();
builder.SetMinimumLevel(LogLevel.Information);
});
// Add JSON file configuration for other app settings not in GlobalSettings
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production"}.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.AddUserSecrets("Bit.Seeder")
.Build();
services.AddSingleton<IConfiguration>(configuration);
// Get global settings
var globalSettings = GlobalSettingsFactory.GlobalSettings;
services.AddSingleton(globalSettings);
// Configure database provider
var provider = globalSettings.DatabaseProvider.ToLowerInvariant() switch
{
"postgres" or "postgresql" => SupportedDatabaseProviders.Postgres,
"mysql" or "mariadb" => SupportedDatabaseProviders.MySql,
"sqlite" => SupportedDatabaseProviders.Sqlite,
_ => SupportedDatabaseProviders.SqlServer
};
var connectionString = provider switch
{
SupportedDatabaseProviders.Postgres => globalSettings.PostgreSql?.ConnectionString,
SupportedDatabaseProviders.MySql => globalSettings.MySql?.ConnectionString,
SupportedDatabaseProviders.Sqlite => globalSettings.Sqlite?.ConnectionString,
_ => globalSettings.SqlServer?.ConnectionString
};
// Register database context
services.AddDbContext<DatabaseContext>(options =>
{
switch (provider)
{
case SupportedDatabaseProviders.Postgres:
options.UseNpgsql(connectionString);
break;
case SupportedDatabaseProviders.MySql:
options.UseMySql(connectionString!, ServerVersion.AutoDetect(connectionString!));
break;
case SupportedDatabaseProviders.Sqlite:
options.UseSqlite(connectionString!);
break;
default:
options.UseSqlServer(connectionString!);
break;
}
});
// Add Data Protection services
services.AddDataProtection()
.SetApplicationName("Bitwarden");
// Register other services
services.AddTransient<ISeederService, SeederService>();
services.AddTransient<IDatabaseService, DatabaseService>();
services.AddTransient<IEncryptionService, EncryptionService>();
Console.WriteLine($"Inner exception: {ex.InnerException.Message}");
}
Console.WriteLine($"Stack trace: {ex.StackTrace}");
return false;
}
}
}
private void ConfigureServices(ServiceCollection services)
{
// Add logging
services.AddLogging(builder =>
{
builder.AddConsole();
builder.SetMinimumLevel(LogLevel.Information);
});
// Add JSON file configuration for other app settings not in GlobalSettings
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production"}.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.AddUserSecrets("Bit.Seeder")
.Build();
services.AddSingleton<IConfiguration>(configuration);
// Get global settings
var globalSettings = GlobalSettingsFactory.GlobalSettings;
services.AddSingleton(globalSettings);
// Configure database provider
var provider = globalSettings.DatabaseProvider.ToLowerInvariant() switch
{
"postgres" or "postgresql" => SupportedDatabaseProviders.Postgres,
"mysql" or "mariadb" => SupportedDatabaseProviders.MySql,
"sqlite" => SupportedDatabaseProviders.Sqlite,
_ => SupportedDatabaseProviders.SqlServer
};
var connectionString = provider switch
{
SupportedDatabaseProviders.Postgres => globalSettings.PostgreSql?.ConnectionString,
SupportedDatabaseProviders.MySql => globalSettings.MySql?.ConnectionString,
SupportedDatabaseProviders.Sqlite => globalSettings.Sqlite?.ConnectionString,
_ => globalSettings.SqlServer?.ConnectionString
};
// Register database context
services.AddDbContext<DatabaseContext>(options =>
{
switch (provider)
{
case SupportedDatabaseProviders.Postgres:
options.UseNpgsql(connectionString);
break;
case SupportedDatabaseProviders.MySql:
options.UseMySql(connectionString!, ServerVersion.AutoDetect(connectionString!));
break;
case SupportedDatabaseProviders.Sqlite:
options.UseSqlite(connectionString!);
break;
default:
options.UseSqlServer(connectionString!);
break;
}
});
// Add Data Protection services
services.AddDataProtection()
.SetApplicationName("Bitwarden");
// Register other services
services.AddTransient<ISeederService, SeederService>();
services.AddTransient<IDatabaseService, DatabaseService>();
services.AddTransient<IEncryptionService, EncryptionService>();
}
}

124
util/seeder/Commands/GenerateCommand.cs
View File

@ -1,77 +1,75 @@
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Bit.Seeder.Services;
using Bit.Seeder.Services;
using Bit.Seeder.Settings;
using Microsoft.AspNetCore.DataProtection;
using Bit.Core;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
namespace Bit.Seeder.Commands
namespace Bit.Seeder.Commands;
public class GenerateCommand
{
public class GenerateCommand
public bool Execute(int users, int ciphersPerUser, string seedName, bool loadImmediately = false)
{
public bool Execute(int users, int ciphersPerUser, string seedName, bool loadImmediately = false)
try
{
try
// Create service provider with necessary services
var services = new ServiceCollection();
ConfigureServices(services);
var serviceProvider = services.BuildServiceProvider();
// Get the seeder service
var seederService = serviceProvider.GetRequiredService<ISeederService>();
var logger = serviceProvider.GetRequiredService<ILogger<GenerateCommand>>();
logger.LogInformation($"Generating seeds for {users} users with {ciphersPerUser} ciphers per user");
logger.LogInformation($"Seed name: {seedName}");
// Execute the appropriate action based on whether we need to load immediately
if (loadImmediately)
{
// Create service provider with necessary services
var services = new ServiceCollection();
ConfigureServices(services);
var serviceProvider = services.BuildServiceProvider();
// Get the seeder service
var seederService = serviceProvider.GetRequiredService<ISeederService>();
var logger = serviceProvider.GetRequiredService<ILogger<GenerateCommand>>();
logger.LogInformation($"Generating seeds for {users} users with {ciphersPerUser} ciphers per user");
logger.LogInformation($"Seed name: {seedName}");
// Execute the appropriate action based on whether we need to load immediately
if (loadImmediately)
{
// Generate and load directly without creating intermediate files
seederService.GenerateAndLoadSeedsAsync(users, ciphersPerUser, seedName).GetAwaiter().GetResult();
logger.LogInformation("Seeds generated and loaded directly to database");
}
else
{
// Only generate seeds and save to files
string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
seederService.GenerateSeedsAsync(users, ciphersPerUser, seedName).GetAwaiter().GetResult();
logger.LogInformation("Seed generation completed successfully");
}
return true;
// Generate and load directly without creating intermediate files
seederService.GenerateAndLoadSeedsAsync(users, ciphersPerUser, seedName).GetAwaiter().GetResult();
logger.LogInformation("Seeds generated and loaded directly to database");
}
catch (Exception ex)
else
{
Console.WriteLine($"Error generating seeds: {ex.Message}");
if (ex.InnerException != null)
{
Console.WriteLine($"Inner exception: {ex.InnerException.Message}");
}
Console.WriteLine($"Stack trace: {ex.StackTrace}");
return false;
// Only generate seeds and save to files
string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
seederService.GenerateSeedsAsync(users, ciphersPerUser, seedName).GetAwaiter().GetResult();
logger.LogInformation("Seed generation completed successfully");
}
return true;
}
private void ConfigureServices(ServiceCollection services)
catch (Exception ex)
{
// Load configuration using the GlobalSettingsFactory
var globalSettings = GlobalSettingsFactory.GlobalSettings;
// Register services
services.AddLogging(builder => builder.AddConsole());
services.AddSingleton(globalSettings);
// Add Data Protection services
services.AddDataProtection()
.SetApplicationName("Bitwarden");
// Register DatabaseContext and services
services.AddTransient<ISeederService, SeederService>();
services.AddTransient<IDatabaseService, DatabaseService>();
services.AddTransient<IEncryptionService, EncryptionService>();
services.AddDbContext<DatabaseContext>();
Console.WriteLine($"Error generating seeds: {ex.Message}");
if (ex.InnerException != null)
{
Console.WriteLine($"Inner exception: {ex.InnerException.Message}");
}
Console.WriteLine($"Stack trace: {ex.StackTrace}");
return false;
}
}
}
private void ConfigureServices(ServiceCollection services)
{
// Load configuration using the GlobalSettingsFactory
var globalSettings = GlobalSettingsFactory.GlobalSettings;
// Register services
services.AddLogging(builder => builder.AddConsole());
services.AddSingleton(globalSettings);
// Add Data Protection services
services.AddDataProtection()
.SetApplicationName("Bitwarden");
// Register DatabaseContext and services
services.AddTransient<ISeederService, SeederService>();
services.AddTransient<IDatabaseService, DatabaseService>();
services.AddTransient<IEncryptionService, EncryptionService>();
services.AddDbContext<DatabaseContext>();
}
}

142
util/seeder/Commands/LoadCommand.cs
View File

@ -1,87 +1,85 @@
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Bit.Seeder.Services;
using Bit.Seeder.Services;
using Bit.Seeder.Settings;
using Microsoft.AspNetCore.DataProtection;
using Bit.Core;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
namespace Bit.Seeder.Commands
namespace Bit.Seeder.Commands;
public class LoadCommand
{
public class LoadCommand
public bool Execute(string seedName, string? timestamp = null, bool dryRun = false)
{
public bool Execute(string seedName, string? timestamp = null, bool dryRun = false)
try
{
try
// Create service provider with necessary services
var services = new ServiceCollection();
ConfigureServices(services);
var serviceProvider = services.BuildServiceProvider();
// Get the necessary services
var seederService = serviceProvider.GetRequiredService<ISeederService>();
var databaseService = serviceProvider.GetRequiredService<IDatabaseService>();
var logger = serviceProvider.GetRequiredService<ILogger<LoadCommand>>();
logger.LogInformation($"Loading seeds named: {seedName}");
if (!string.IsNullOrEmpty(timestamp))
{
// Create service provider with necessary services
var services = new ServiceCollection();
ConfigureServices(services);
var serviceProvider = services.BuildServiceProvider();
logger.LogInformation($"Using specific timestamp: {timestamp}");
}
// Get the necessary services
var seederService = serviceProvider.GetRequiredService<ISeederService>();
var databaseService = serviceProvider.GetRequiredService<IDatabaseService>();
var logger = serviceProvider.GetRequiredService<ILogger<LoadCommand>>();
logger.LogInformation($"Loading seeds named: {seedName}");
if (!string.IsNullOrEmpty(timestamp))
{
logger.LogInformation($"Using specific timestamp: {timestamp}");
}
if (dryRun)
{
logger.LogInformation("DRY RUN: No actual changes will be made to the database");
// Perform validation here if needed
logger.LogInformation("Seed loading validation completed");
return true;
}
// Execute the load operation
seederService.LoadSeedsAsync(seedName, timestamp).GetAwaiter().GetResult();
logger.LogInformation("Seed loading completed successfully");
if (dryRun)
{
logger.LogInformation("DRY RUN: No actual changes will be made to the database");
// Perform validation here if needed
logger.LogInformation("Seed loading validation completed");
return true;
}
catch (Exception ex)
{
// Display the full exception details
Console.WriteLine($"Error loading seeds: {ex.Message}");
if (ex.InnerException != null)
{
Console.WriteLine($"Inner exception: {ex.InnerException.Message}");
if (ex.InnerException.InnerException != null)
{
Console.WriteLine($"Inner inner exception: {ex.InnerException.InnerException.Message}");
}
}
Console.WriteLine($"Stack trace: {ex.StackTrace}");
return false;
}
// Execute the load operation
seederService.LoadSeedsAsync(seedName, timestamp).GetAwaiter().GetResult();
logger.LogInformation("Seed loading completed successfully");
return true;
}
private void ConfigureServices(ServiceCollection services)
catch (Exception ex)
{
// Load configuration using the GlobalSettingsFactory
var globalSettings = GlobalSettingsFactory.GlobalSettings;
// Display the full exception details
Console.WriteLine($"Error loading seeds: {ex.Message}");
// Register services
services.AddLogging(builder => builder.AddConsole());
services.AddSingleton(globalSettings);
// Add Data Protection services
services.AddDataProtection()
.SetApplicationName("Bitwarden");
// Register DatabaseContext and services
services.AddTransient<ISeederService, SeederService>();
services.AddTransient<IDatabaseService, DatabaseService>();
services.AddTransient<IEncryptionService, EncryptionService>();
services.AddDbContext<DatabaseContext>();
if (ex.InnerException != null)
{
Console.WriteLine($"Inner exception: {ex.InnerException.Message}");
if (ex.InnerException.InnerException != null)
{
Console.WriteLine($"Inner inner exception: {ex.InnerException.InnerException.Message}");
}
}
Console.WriteLine($"Stack trace: {ex.StackTrace}");
return false;
}
}
}
private void ConfigureServices(ServiceCollection services)
{
// Load configuration using the GlobalSettingsFactory
var globalSettings = GlobalSettingsFactory.GlobalSettings;
// Register services
services.AddLogging(builder => builder.AddConsole());
services.AddSingleton(globalSettings);
// Add Data Protection services
services.AddDataProtection()
.SetApplicationName("Bitwarden");
// Register DatabaseContext and services
services.AddTransient<ISeederService, SeederService>();
services.AddTransient<IDatabaseService, DatabaseService>();
services.AddTransient<IEncryptionService, EncryptionService>();
services.AddDbContext<DatabaseContext>();
}
}

16
util/seeder/DataProtection-Keys/key-c9676c44-16a7-4b38-b750-4ea5443f1b87.xml
View File

@ -1,16 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<key id="c9676c44-16a7-4b38-b750-4ea5443f1b87" version="1">
<creationDate>2025-03-13T17:13:50.8174933Z</creationDate>
<activationDate>2025-03-13T17:13:50.8130955Z</activationDate>
<expirationDate>2025-06-11T17:13:50.8130955Z</expirationDate>
<descriptor deserializerType="Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.AuthenticatedEncryptorDescriptorDeserializer, Microsoft.AspNetCore.DataProtection, Version=8.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60">
<descriptor>
<encryption algorithm="AES_256_CBC" />
<validation algorithm="HMACSHA256" />
<masterKey p4:requiresEncryption="true" xmlns:p4="http://schemas.asp.net/2015/03/dataProtection">
<!-- Warning: the key below is in an unencrypted form. -->
<value>VCxxS1xKEWQ9+XRXgMchHML7POXcwRkCHswj7JMjjN36RkERENo+ky/1mazB4RZ6BjjwXsAyjhSz2eGts/0BnQ==</value>
</masterKey>
</descriptor>
</descriptor>
</key>

11
util/seeder/Services/DatabaseContext.cs
View File

@ -1,8 +1,7 @@
using Microsoft.EntityFrameworkCore;
using Bit.Core.Entities;
using Bit.Core.Entities;
using Bit.Core.Vault.Entities;
using Bit.Core.Enums;
using Bit.Seeder.Settings;
using Microsoft.EntityFrameworkCore;
namespace Bit.Seeder.Services;
@ -22,13 +21,13 @@ public class DatabaseContext : DbContext
{
var provider = _globalSettings.DatabaseProvider ?? string.Empty;
Console.WriteLine($"Database Provider: '{provider}'");
// Output all available connection strings for debugging
Console.WriteLine($"SqlServer ConnectionString available: {!string.IsNullOrEmpty(_globalSettings.SqlServer?.ConnectionString)}");
Console.WriteLine($"PostgreSql ConnectionString available: {!string.IsNullOrEmpty(_globalSettings.PostgreSql?.ConnectionString)}");
Console.WriteLine($"MySql ConnectionString available: {!string.IsNullOrEmpty(_globalSettings.MySql?.ConnectionString)}");
Console.WriteLine($"Sqlite ConnectionString available: {!string.IsNullOrEmpty(_globalSettings.Sqlite?.ConnectionString)}");
var connectionString = _globalSettings.DatabaseProvider switch
{
"postgres" => _globalSettings.PostgreSql?.ConnectionString,
@ -73,4 +72,4 @@ public class DatabaseContext : DbContext
entity.Property(e => e.Kdf).HasConversion<int>();
});
}
}
}

4
util/seeder/Services/DatabaseService.cs
View File

@ -1,7 +1,7 @@
using Bit.Core.Entities;
using Bit.Core.Vault.Entities;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Bit.Core.Entities;
using Bit.Core.Vault.Entities;
namespace Bit.Seeder.Services;

26
util/seeder/Services/EncryptionService.cs
View File

@ -1,8 +1,8 @@
using System.Security.Cryptography;
using System.Security.Cryptography;
using System.Text;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.DataProtection;
using Bit.Core;
using Microsoft.AspNetCore.DataProtection;
using Microsoft.Extensions.Logging;
namespace Bit.Seeder.Services;
@ -22,11 +22,11 @@ public class EncryptionService : IEncryptionService
public string HashPassword(string password)
{
_logger.LogDebug("Hashing password using Data Protection");
// The real Bitwarden implementation uses BCrypt first and then protects that value
// For simplicity we're just protecting the raw password since this is only for seeding test data
var protectedPassword = _dataProtector.Protect(password);
// Prefix with "P|" to match Bitwarden's password format
return string.Concat(Constants.DatabaseFieldProtectedPrefix, protectedPassword);
}
@ -34,33 +34,33 @@ public class EncryptionService : IEncryptionService
public byte[] DeriveKey(string password, string salt)
{
_logger.LogDebug("Deriving key");
using var pbkdf2 = new Rfc2898DeriveBytes(
Encoding.UTF8.GetBytes(password),
Encoding.UTF8.GetBytes(salt),
100000,
HashAlgorithmName.SHA256);
return pbkdf2.GetBytes(32);
}
public string EncryptString(string plaintext, byte[] key)
{
_logger.LogDebug("Encrypting string");
using var aes = Aes.Create();
aes.Key = key;
aes.GenerateIV();
using var encryptor = aes.CreateEncryptor();
var plaintextBytes = Encoding.UTF8.GetBytes(plaintext);
var cipherBytes = encryptor.TransformFinalBlock(plaintextBytes, 0, plaintextBytes.Length);
var result = new byte[aes.IV.Length + cipherBytes.Length];
Buffer.BlockCopy(aes.IV, 0, result, 0, aes.IV.Length);
Buffer.BlockCopy(cipherBytes, 0, result, aes.IV.Length, cipherBytes.Length);
return Convert.ToBase64String(result);
}
}
}

2
util/seeder/Services/IDatabaseService.cs
View File

@ -1,4 +1,4 @@
using Bit.Core.Entities;
using Bit.Core.Entities;
using Bit.Core.Vault.Entities;
namespace Bit.Seeder.Services;

11
util/seeder/Services/IDatabaseService.cs.bak
View File

@ -1,11 +0,0 @@
using Bit.Core.Entities;
using Bit.Core.Vault.Entities;
namespace Bit.Seeder.Services;
public interface IDatabaseService
{
Task ClearDatabaseAsync();
Task SaveUsersAsync(IEnumerable<User> users);
Task SaveCiphersAsync(IEnumerable<Cipher> ciphers);
}

4
util/seeder/Services/IEncryptionService.cs
View File

@ -1,8 +1,8 @@
namespace Bit.Seeder.Services;
namespace Bit.Seeder.Services;
public interface IEncryptionService
{
string HashPassword(string password);
byte[] DeriveKey(string password, string salt);
string EncryptString(string plaintext, byte[] key);
}
}

2
util/seeder/Services/ISeederService.cs
View File

@ -1,4 +1,4 @@
namespace Bit.Seeder.Services;
namespace Bit.Seeder.Services;
public interface ISeederService
{

146
util/seeder/Services/SeederService.cs
View File

@ -1,4 +1,4 @@
using System.Text.Json;
using System.Text.Json;
using Bit.Core.Entities;
using Bit.Core.Enums;
using Bit.Core.Vault.Entities;
@ -25,7 +25,7 @@ public class SeederService : ISeederService
_databaseService = databaseService;
_logger = logger;
_faker = new Faker();
// Set the random seed to ensure reproducible data
Randomizer.Seed = new Random(42);
}
@ -33,34 +33,34 @@ public class SeederService : ISeederService
public async Task GenerateSeedsAsync(int userCount, int ciphersPerUser, string outputName)
{
_logger.LogInformation("Generating seeds: {UserCount} users with {CiphersPerUser} ciphers each", userCount, ciphersPerUser);
// Create timestamped folder under a named folder in seeds directory
var seedsBaseDir = Path.Combine(Directory.GetCurrentDirectory(), "seeds");
Directory.CreateDirectory(seedsBaseDir);
var namedDir = Path.Combine(seedsBaseDir, outputName);
Directory.CreateDirectory(namedDir);
var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
var outputDir = Path.Combine(namedDir, timestamp);
Directory.CreateDirectory(outputDir);
// Create users and ciphers subdirectories
Directory.CreateDirectory(Path.Combine(outputDir, "users"));
Directory.CreateDirectory(Path.Combine(outputDir, "ciphers"));
_logger.LogInformation("Seed output directory: {OutputDir}", outputDir);
// Generate users
var users = GenerateUsers(userCount);
// Generate ciphers for each user
var allCiphers = new List<Cipher>();
foreach (var user in users)
{
var ciphers = GenerateCiphers(user, ciphersPerUser);
allCiphers.AddRange(ciphers);
// Save each user's ciphers to a file
var cipherFilePath = Path.Combine(outputDir, "ciphers", $"{user.Id}.json");
await File.WriteAllTextAsync(cipherFilePath, JsonSerializer.Serialize(ciphers, new JsonSerializerOptions
@ -68,33 +68,33 @@ public class SeederService : ISeederService
WriteIndented = true
}));
}
// Save users to a file
var userFilePath = Path.Combine(outputDir, "users", "users.json");
await File.WriteAllTextAsync(userFilePath, JsonSerializer.Serialize(users, new JsonSerializerOptions
{
WriteIndented = true
}));
_logger.LogInformation("Successfully generated {UserCount} users and {CipherCount} ciphers", users.Count, allCiphers.Count);
_logger.LogInformation("Seed data saved to directory: {OutputDir}", outputDir);
}
public async Task GenerateAndLoadSeedsAsync(int userCount, int ciphersPerUser, string seedName)
{
_logger.LogInformation("Generating and loading seeds directly: {UserCount} users with {CiphersPerUser} ciphers each",
_logger.LogInformation("Generating and loading seeds directly: {UserCount} users with {CiphersPerUser} ciphers each",
userCount, ciphersPerUser);
// Generate users directly without saving to files
var users = GenerateUsers(userCount);
// Clear the database first
await _databaseService.ClearDatabaseAsync();
// Save users to database
await _databaseService.SaveUsersAsync(users);
_logger.LogInformation("Saved {UserCount} users directly to database", users.Count);
// Generate and save ciphers for each user
int totalCiphers = 0;
foreach (var user in users)
@ -102,11 +102,11 @@ public class SeederService : ISeederService
var ciphers = GenerateCiphers(user, ciphersPerUser);
await _databaseService.SaveCiphersAsync(ciphers);
totalCiphers += ciphers.Count;
_logger.LogInformation("Saved {CipherCount} ciphers for user {UserId} directly to database",
_logger.LogInformation("Saved {CipherCount} ciphers for user {UserId} directly to database",
ciphers.Count, user.Id);
}
_logger.LogInformation("Successfully generated and loaded {UserCount} users and {CipherCount} ciphers directly to database",
_logger.LogInformation("Successfully generated and loaded {UserCount} users and {CipherCount} ciphers directly to database",
users.Count, totalCiphers);
}
@ -115,15 +115,15 @@ public class SeederService : ISeederService
// Construct path to seeds directory
var seedsBaseDir = Path.Combine(Directory.GetCurrentDirectory(), "seeds");
var namedDir = Path.Combine(seedsBaseDir, seedName);
if (!Directory.Exists(namedDir))
{
_logger.LogError("Seed directory not found: {SeedDir}", namedDir);
return;
}
string seedDir;
// If timestamp is specified, use that exact directory
if (!string.IsNullOrEmpty(timestamp))
{
@ -143,21 +143,21 @@ public class SeederService : ISeederService
_logger.LogError("No seed data found in directory: {SeedDir}", namedDir);
return;
}
// Sort by directory name (which is a timestamp) in descending order
Array.Sort(timestampDirs);
Array.Reverse(timestampDirs);
// Use the most recent one
seedDir = timestampDirs[0];
_logger.LogInformation("Using most recent seed data from: {SeedDir}", seedDir);
}
_logger.LogInformation("Loading seeds from directory: {SeedDir}", seedDir);
// Clear database first
await _databaseService.ClearDatabaseAsync();
// Load users
var userFilePath = Path.Combine(seedDir, "users", "users.json");
if (!File.Exists(userFilePath))
@ -165,22 +165,22 @@ public class SeederService : ISeederService
_logger.LogError("User file not found: {UserFilePath}", userFilePath);
return;
}
var userJson = await File.ReadAllTextAsync(userFilePath);
var users = JsonSerializer.Deserialize<List<User>>(userJson, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
}) ?? new List<User>();
if (users.Count == 0)
{
_logger.LogError("No users found in user file");
return;
}
// Save users to database
await _databaseService.SaveUsersAsync(users);
// Load and save ciphers for each user
var cipherDir = Path.Combine(seedDir, "ciphers");
if (!Directory.Exists(cipherDir))
@ -188,7 +188,7 @@ public class SeederService : ISeederService
_logger.LogError("Cipher directory not found: {CipherDir}", cipherDir);
return;
}
var cipherFiles = Directory.GetFiles(cipherDir, "*.json");
foreach (var cipherFile in cipherFiles)
{
@ -197,37 +197,37 @@ public class SeederService : ISeederService
{
PropertyNameCaseInsensitive = true
}) ?? new List<Cipher>();
if (ciphers.Count > 0)
{
await _databaseService.SaveCiphersAsync(ciphers);
}
}
_logger.LogInformation("Successfully loaded seed data into database");
}
public async Task ExtractSeedsAsync(string seedName)
{
_logger.LogInformation("Extracting seed data from database for seed name: {SeedName}", seedName);
// Create timestamped folder under a named folder in seeds directory
var seedsBaseDir = Path.Combine(Directory.GetCurrentDirectory(), "seeds");
Directory.CreateDirectory(seedsBaseDir);
var namedDir = Path.Combine(seedsBaseDir, seedName);
Directory.CreateDirectory(namedDir);
var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
var outputDir = Path.Combine(namedDir, timestamp);
Directory.CreateDirectory(outputDir);
// Create users and ciphers subdirectories
Directory.CreateDirectory(Path.Combine(outputDir, "users"));
Directory.CreateDirectory(Path.Combine(outputDir, "ciphers"));
_logger.LogInformation("Seed output directory: {OutputDir}", outputDir);
try
{
// Get all users from the database
@ -237,16 +237,16 @@ public class SeederService : ISeederService
_logger.LogWarning("No users found in the database");
return;
}
_logger.LogInformation("Extracted {Count} users from database", users.Count);
// Save users to a file
var userFilePath = Path.Combine(outputDir, "users", "users.json");
await File.WriteAllTextAsync(userFilePath, JsonSerializer.Serialize(users, new JsonSerializerOptions
{
WriteIndented = true
}));
int totalCiphers = 0;
// Get ciphers for each user
foreach (var user in users)
@ -263,7 +263,7 @@ public class SeederService : ISeederService
totalCiphers += ciphers.Count;
}
}
_logger.LogInformation("Successfully extracted {UserCount} users and {CipherCount} ciphers", users.Count, totalCiphers);
_logger.LogInformation("Seed data saved to directory: {OutputDir}", outputDir);
}
@ -273,13 +273,13 @@ public class SeederService : ISeederService
throw;
}
}
private List<User> GenerateUsers(int count)
{
_logger.LogInformation("Generating {Count} users", count);
var users = new List<User>();
for (int i = 0; i < count; i++)
{
var userId = Guid.NewGuid();
@ -288,7 +288,7 @@ public class SeederService : ISeederService
var masterPassword = _encryptionService.HashPassword(_defaultPassword);
var masterPasswordHint = "It's the word 'password'";
var key = _encryptionService.DeriveKey(_defaultPassword, email);
var user = new User
{
Id = userId,
@ -305,35 +305,35 @@ public class SeederService : ISeederService
RevisionDate = DateTime.UtcNow,
Key = _encryptionService.EncryptString(Convert.ToBase64String(key), key)
};
users.Add(user);
}
return users;
}
private List<Cipher> GenerateCiphers(User user, int count)
{
_logger.LogInformation("Generating {Count} ciphers for user {UserId}", count, user.Id);
var ciphers = new List<Cipher>();
var key = _encryptionService.DeriveKey(_defaultPassword, user.Email);
for (int i = 0; i < count; i++)
{
var cipherId = Guid.NewGuid();
CipherType type;
string name;
string? notes = null;
var typeRandom = _faker.Random.Int(1, 4);
type = (CipherType)typeRandom;
switch (type)
{
case CipherType.Login:
name = $"Login - {_faker.Internet.DomainName()}";
var loginData = new
var loginData = new
{
Name = name,
Notes = notes,
@ -344,9 +344,9 @@ public class SeederService : ISeederService
new { Uri = $"https://{_faker.Internet.DomainName()}" }
}
};
var loginDataJson = JsonSerializer.Serialize(loginData);
ciphers.Add(new Cipher
{
Id = cipherId,
@ -358,19 +358,19 @@ public class SeederService : ISeederService
Reprompt = CipherRepromptType.None
});
break;
case CipherType.SecureNote:
name = $"Note - {_faker.Lorem.Word()}";
notes = _faker.Lorem.Paragraph();
var secureNoteData = new
var secureNoteData = new
{
Name = name,
Notes = notes,
Type = 0 // Text
};
var secureNoteDataJson = JsonSerializer.Serialize(secureNoteData);
ciphers.Add(new Cipher
{
Id = cipherId,
@ -382,10 +382,10 @@ public class SeederService : ISeederService
Reprompt = CipherRepromptType.None
});
break;
case CipherType.Card:
name = $"Card - {_faker.Finance.CreditCardNumber().Substring(0, 4)}";
var cardData = new
var cardData = new
{
Name = name,
Notes = notes,
@ -395,9 +395,9 @@ public class SeederService : ISeederService
ExpYear = _faker.Random.Int(DateTime.UtcNow.Year, DateTime.UtcNow.Year + 10).ToString(),
Code = _faker.Random.Int(100, 999).ToString()
};
var cardDataJson = JsonSerializer.Serialize(cardData);
ciphers.Add(new Cipher
{
Id = cipherId,
@ -409,10 +409,10 @@ public class SeederService : ISeederService
Reprompt = CipherRepromptType.None
});
break;
case CipherType.Identity:
name = $"Identity - {_faker.Name.FullName()}";
var identityData = new
var identityData = new
{
Name = name,
Notes = notes,
@ -428,9 +428,9 @@ public class SeederService : ISeederService
PostalCode = _faker.Address.ZipCode(),
Country = _faker.Address.CountryCode()
};
var identityDataJson = JsonSerializer.Serialize(identityData);
ciphers.Add(new Cipher
{
Id = cipherId,
@ -444,7 +444,7 @@ public class SeederService : ISeederService
break;
}
}
return ciphers;
}
}
}

383
util/seeder/Services/SeederService.cs.bak
View File

@ -1,383 +0,0 @@
using System.Text.Json;
using Bit.Core.Entities;
using Bit.Core.Enums;
using Bit.Core.Vault.Entities;
using Bit.Core.Vault.Enums;
using Bogus;
using Microsoft.Extensions.Logging;
namespace Bit.Seeder.Services;
public class SeederService : ISeederService
{
private readonly IEncryptionService _encryptionService;
private readonly IDatabaseService _databaseService;
private readonly ILogger<SeederService> _logger;
private readonly Faker _faker;
private readonly string _defaultPassword = "password";
public SeederService(
IEncryptionService encryptionService,
IDatabaseService databaseService,
ILogger<SeederService> logger)
{
_encryptionService = encryptionService;
_databaseService = databaseService;
_logger = logger;
_faker = new Faker();
// Set the random seed to ensure reproducible data
Randomizer.Seed = new Random(42);
}
public async Task GenerateSeedsAsync(int userCount, int ciphersPerUser, string outputName)
{
_logger.LogInformation("Generating seeds: {UserCount} users with {CiphersPerUser} ciphers each", userCount, ciphersPerUser);
// Create timestamped folder under a named folder in seeds directory
var seedsBaseDir = Path.Combine(Directory.GetCurrentDirectory(), "seeds");
Directory.CreateDirectory(seedsBaseDir);
var namedDir = Path.Combine(seedsBaseDir, outputName);
Directory.CreateDirectory(namedDir);
var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
var outputDir = Path.Combine(namedDir, timestamp);
Directory.CreateDirectory(outputDir);
// Create users and ciphers subdirectories
Directory.CreateDirectory(Path.Combine(outputDir, "users"));
Directory.CreateDirectory(Path.Combine(outputDir, "ciphers"));
_logger.LogInformation("Seed output directory: {OutputDir}", outputDir);
// Generate users
var users = GenerateUsers(userCount);
// Generate ciphers for each user
var allCiphers = new List<Cipher>();
foreach (var user in users)
{
var ciphers = GenerateCiphers(user, ciphersPerUser);
allCiphers.AddRange(ciphers);
// Save each user's ciphers to a file
var cipherFilePath = Path.Combine(outputDir, "ciphers", $"{user.Id}.json");
await File.WriteAllTextAsync(cipherFilePath, JsonSerializer.Serialize(ciphers, new JsonSerializerOptions
{
WriteIndented = true
}));
}
// Save users to a file
var userFilePath = Path.Combine(outputDir, "users", "users.json");
await File.WriteAllTextAsync(userFilePath, JsonSerializer.Serialize(users, new JsonSerializerOptions
{
WriteIndented = true
}));
_logger.LogInformation("Successfully generated {UserCount} users and {CipherCount} ciphers", users.Count, allCiphers.Count);
_logger.LogInformation("Seed data saved to directory: {OutputDir}", outputDir);
}
public async Task GenerateAndLoadSeedsAsync(int userCount, int ciphersPerUser, string seedName)
{
_logger.LogInformation("Generating and loading seeds directly: {UserCount} users with {CiphersPerUser} ciphers each",
userCount, ciphersPerUser);
// Generate users directly without saving to files
var users = GenerateUsers(userCount);
// Clear the database first
await _databaseService.ClearDatabaseAsync();
// Save users to database
await _databaseService.SaveUsersAsync(users);
_logger.LogInformation("Saved {UserCount} users directly to database", users.Count);
// Generate and save ciphers for each user
int totalCiphers = 0;
foreach (var user in users)
{
var ciphers = GenerateCiphers(user, ciphersPerUser);
await _databaseService.SaveCiphersAsync(ciphers);
totalCiphers += ciphers.Count;
_logger.LogInformation("Saved {CipherCount} ciphers for user {UserId} directly to database",
ciphers.Count, user.Id);
}
_logger.LogInformation("Successfully generated and loaded {UserCount} users and {CipherCount} ciphers directly to database",
users.Count, totalCiphers);
}
public async Task LoadSeedsAsync(string seedName, string? timestamp = null)
{
// Construct path to seeds directory
var seedsBaseDir = Path.Combine(Directory.GetCurrentDirectory(), "seeds");
var namedDir = Path.Combine(seedsBaseDir, seedName);
if (!Directory.Exists(namedDir))
{
_logger.LogError("Seed directory not found: {SeedDir}", namedDir);
return;
}
string seedDir;
// If timestamp is specified, use that exact directory
if (!string.IsNullOrEmpty(timestamp))
{
seedDir = Path.Combine(namedDir, timestamp);
if (!Directory.Exists(seedDir))
{
_logger.LogError("Timestamp directory not found: {TimestampDir}", seedDir);
return;
}
}
else
{
// Otherwise, find the most recent timestamped directory
var timestampDirs = Directory.GetDirectories(namedDir);
if (timestampDirs.Length == 0)
{
_logger.LogError("No seed data found in directory: {SeedDir}", namedDir);
return;
}
// Sort by directory name (which is a timestamp) in descending order
Array.Sort(timestampDirs);
Array.Reverse(timestampDirs);
// Use the most recent one
seedDir = timestampDirs[0];
_logger.LogInformation("Using most recent seed data from: {SeedDir}", seedDir);
}
_logger.LogInformation("Loading seeds from directory: {SeedDir}", seedDir);
// Clear database first
await _databaseService.ClearDatabaseAsync();
// Load users
var userFilePath = Path.Combine(seedDir, "users", "users.json");
if (!File.Exists(userFilePath))
{
_logger.LogError("User file not found: {UserFilePath}", userFilePath);
return;
}
var userJson = await File.ReadAllTextAsync(userFilePath);
var users = JsonSerializer.Deserialize<List<User>>(userJson, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
}) ?? new List<User>();
if (users.Count == 0)
{
_logger.LogError("No users found in user file");
return;
}
// Save users to database
await _databaseService.SaveUsersAsync(users);
// Load and save ciphers for each user
var cipherDir = Path.Combine(seedDir, "ciphers");
if (!Directory.Exists(cipherDir))
{
_logger.LogError("Cipher directory not found: {CipherDir}", cipherDir);
return;
}
var cipherFiles = Directory.GetFiles(cipherDir, "*.json");
foreach (var cipherFile in cipherFiles)
{
var cipherJson = await File.ReadAllTextAsync(cipherFile);
var ciphers = JsonSerializer.Deserialize<List<Cipher>>(cipherJson, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
}) ?? new List<Cipher>();
if (ciphers.Count > 0)
{
await _databaseService.SaveCiphersAsync(ciphers);
}
}
_logger.LogInformation("Successfully loaded seed data into database");
}
private List<User> GenerateUsers(int count)
{
_logger.LogInformation("Generating {Count} users", count);
var users = new List<User>();
for (int i = 0; i < count; i++)
{
var userId = Guid.NewGuid();
var email = _faker.Internet.Email(provider: "example.com");
var name = _faker.Name.FullName();
var masterPassword = _encryptionService.HashPassword(_defaultPassword);
var masterPasswordHint = "It's the word 'password'";
var key = _encryptionService.DeriveKey(_defaultPassword, email);
var user = new User
{
Id = userId,
Email = email,
Name = name,
MasterPassword = masterPassword,
MasterPasswordHint = masterPasswordHint,
SecurityStamp = Guid.NewGuid().ToString(),
EmailVerified = true,
ApiKey = Guid.NewGuid().ToString("N").Substring(0, 30),
Kdf = KdfType.PBKDF2_SHA256,
KdfIterations = 100000,
CreationDate = DateTime.UtcNow,
RevisionDate = DateTime.UtcNow,
Key = _encryptionService.EncryptString(Convert.ToBase64String(key), key)
};
users.Add(user);
}
return users;
}
private List<Cipher> GenerateCiphers(User user, int count)
{
_logger.LogInformation("Generating {Count} ciphers for user {UserId}", count, user.Id);
var ciphers = new List<Cipher>();
var key = _encryptionService.DeriveKey(_defaultPassword, user.Email);
for (int i = 0; i < count; i++)
{
var cipherId = Guid.NewGuid();
CipherType type;
string name;
string? notes = null;
var typeRandom = _faker.Random.Int(1, 4);
type = (CipherType)typeRandom;
switch (type)
{
case CipherType.Login:
name = $"Login - {_faker.Internet.DomainName()}";
var loginData = new
{
Name = name,
Notes = notes,
Username = _faker.Internet.UserName(),
Password = _faker.Internet.Password(),
Uris = new[]
{
new { Uri = $"https://{_faker.Internet.DomainName()}" }
}
};
var loginDataJson = JsonSerializer.Serialize(loginData);
ciphers.Add(new Cipher
{
Id = cipherId,
UserId = user.Id,
Type = type,
Data = _encryptionService.EncryptString(loginDataJson, key),
CreationDate = DateTime.UtcNow,
RevisionDate = DateTime.UtcNow,
Reprompt = CipherRepromptType.None
});
break;
case CipherType.SecureNote:
name = $"Note - {_faker.Lorem.Word()}";
notes = _faker.Lorem.Paragraph();
var secureNoteData = new
{
Name = name,
Notes = notes,
Type = 0 // Text
};
var secureNoteDataJson = JsonSerializer.Serialize(secureNoteData);
ciphers.Add(new Cipher
{
Id = cipherId,
UserId = user.Id,
Type = type,
Data = _encryptionService.EncryptString(secureNoteDataJson, key),
CreationDate = DateTime.UtcNow,
RevisionDate = DateTime.UtcNow,
Reprompt = CipherRepromptType.None
});
break;
case CipherType.Card:
name = $"Card - {_faker.Finance.CreditCardNumber().Substring(0, 4)}";
var cardData = new
{
Name = name,
Notes = notes,
CardholderName = _faker.Name.FullName(),
Number = _faker.Finance.CreditCardNumber(),
ExpMonth = _faker.Random.Int(1, 12).ToString(),
ExpYear = _faker.Random.Int(DateTime.UtcNow.Year, DateTime.UtcNow.Year + 10).ToString(),
Code = _faker.Random.Int(100, 999).ToString()
};
var cardDataJson = JsonSerializer.Serialize(cardData);
ciphers.Add(new Cipher
{
Id = cipherId,
UserId = user.Id,
Type = type,
Data = _encryptionService.EncryptString(cardDataJson, key),
CreationDate = DateTime.UtcNow,
RevisionDate = DateTime.UtcNow,
Reprompt = CipherRepromptType.None
});
break;
case CipherType.Identity:
name = $"Identity - {_faker.Name.FullName()}";
var identityData = new
{
Name = name,
Notes = notes,
Title = _faker.Name.Prefix(),
FirstName = _faker.Name.FirstName(),
MiddleName = _faker.Name.FirstName(),
LastName = _faker.Name.LastName(),
Email = _faker.Internet.Email(),
Phone = _faker.Phone.PhoneNumber(),
Address1 = _faker.Address.StreetAddress(),
City = _faker.Address.City(),
State = _faker.Address.State(),
PostalCode = _faker.Address.ZipCode(),
Country = _faker.Address.CountryCode()
};
var identityDataJson = JsonSerializer.Serialize(identityData);
ciphers.Add(new Cipher
{
Id = cipherId,
UserId = user.Id,
Type = type,
Data = _encryptionService.EncryptString(identityDataJson, key),
CreationDate = DateTime.UtcNow,
RevisionDate = DateTime.UtcNow,
Reprompt = CipherRepromptType.None
});
break;
}
}
return ciphers;
}
}

4
util/seeder/Settings/GlobalSettings.cs
View File

@ -1,4 +1,4 @@
namespace Bit.Seeder.Settings;
namespace Bit.Seeder.Settings;
public class GlobalSettings
{
@ -13,4 +13,4 @@ public class GlobalSettings
{
public string ConnectionString { get; set; } = string.Empty;
}
}
}

20
util/seeder/Settings/GlobalSettingsFactory.cs
View File

@ -1,4 +1,4 @@
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Configuration;
namespace Bit.Seeder.Settings;
@ -14,7 +14,7 @@ public static class GlobalSettingsFactory
{
_globalSettings = LoadGlobalSettings();
}
return _globalSettings;
}
}
@ -22,7 +22,7 @@ public static class GlobalSettingsFactory
private static GlobalSettings LoadGlobalSettings()
{
Console.WriteLine("Loading global settings...");
var configBuilder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
@ -32,7 +32,7 @@ public static class GlobalSettingsFactory
var configuration = configBuilder.Build();
var globalSettingsSection = configuration.GetSection("globalSettings");
// Debug: Print all settings from globalSettings section
foreach (var setting in globalSettingsSection.GetChildren())
{
@ -42,23 +42,23 @@ public static class GlobalSettingsFactory
Console.WriteLine($" - {setting.Key}.{child.Key}");
}
}
var settings = new GlobalSettings();
globalSettingsSection.Bind(settings);
// Output the loaded settings
Console.WriteLine($"Loaded DatabaseProvider: {settings.DatabaseProvider}");
Console.WriteLine($"PostgreSql settings loaded: {settings.PostgreSql != null}");
Console.WriteLine($"SqlServer settings loaded: {settings.SqlServer != null}");
Console.WriteLine($"MySql settings loaded: {settings.MySql != null}");
Console.WriteLine($"Sqlite settings loaded: {settings.Sqlite != null}");
// Check for case sensitivity issue with PostgreSql/postgresql keys
var postgresqlValue = globalSettingsSection.GetSection("postgresql")?.Value;
var postgreSqlValue = globalSettingsSection.GetSection("postgreSql")?.Value;
Console.WriteLine($"Raw check - postgresql setting exists: {postgresqlValue != null}");
Console.WriteLine($"Raw check - postgreSql setting exists: {postgreSqlValue != null}");
return settings;
}
}
@ -71,7 +71,7 @@ public class GlobalSettingsFactoryWithArgs
public GlobalSettingsFactoryWithArgs(string[] args)
{
GlobalSettings = new GlobalSettings();
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
@ -83,4 +83,4 @@ public class GlobalSettingsFactoryWithArgs
config.GetSection("globalSettings").Bind(GlobalSettings);
}
}
}