public async Task CanGetJwt()
{
var sut = await VaultHelper.CreateAsync(Config);
var secret = await sut.GetLiveSecretAsync("JWT", SecretGetters.MakeJwtGetter("auth", TimeSpan.FromSeconds(1), "vandelay", "tester"));
var firstValue = secret.Value;
firstValue.Should().NotBeEmpty();
await Task.Delay(TimeSpan.FromSeconds(1));
var secondValue = secret.Value;
secondValue.Should().NotBeEmpty();
secondValue.Should().NotBe(firstValue, "the token should have been refreshed");
secret.Dispose();
await Task.Delay(TimeSpan.FromSeconds(1));
Func <string> lateGet = () => secret.Value;
lateGet.Should().Throw <Exception>("the secret value cannot be read after it is disposed");
}
public async Task CanStartClient()
{
var sut = await VaultHelper.CreateAsync(Config);
_testOutputHelper.WriteLine("Got result.");
sut.Should().NotBeNull();
}
public (Mock <IVaultApi>, IVaultHelper) GetMocks(SecretAuth auth = null)
{
auth = auth ?? new SecretAuth
{
LeaseDuration = 0
};
var mockClient = new Mock <IVaultApi>(MockBehavior.Strict);
var mockLoginStrategy = new Mock <ILoginStrategy>(MockBehavior.Strict);
mockLoginStrategy.Setup(m => m.LoginAsync(It.IsAny <string>(), It.IsAny <ILogger>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new LoginResult()
{
Client = mockClient.Object,
SecretAuth = auth
}));
Config.LoginStrategies = new List <ILoginStrategy>()
{
mockLoginStrategy.Object
};
var sut = VaultHelper.CreateAsync(Config).Result;
return(mockClient, sut);
}
protected override void BeginWork()
{
base.BeginWork();
var jobParameters = Utils.SmartXmlDeserializer(BootParameters);
var isEDocsJob = false;
var profileBEO = jobParameters as ProfileBEO;
if (profileBEO != null)
{
ThreadsLinkingRequested = profileBEO.IsMapEmailThread;
FamiliesLinkingRequested = profileBEO.IsImportFamilyRelations;
if (profileBEO.ImportTypeName.Contains("E-docs"))
{
isEDocsJob = true;
ThreadsLinkingRequested = true;
FamiliesLinkingRequested = true;
}
CollectionId = profileBEO.DatasetDetails.CollectionId;
MatterId = profileBEO.DatasetDetails.Matter.FolderID;
IsOverlay = !profileBEO.IsAppend;
}
var lawImportBEO = jobParameters as LawImportBEO;
if (lawImportBEO != null)
{
ThreadsLinkingRequested = lawImportBEO.CreateThreads;
FamiliesLinkingRequested = lawImportBEO.CreateFamilyGroups;
CollectionId = lawImportBEO.CollectionId;
MatterId = lawImportBEO.MatterId;
IsOverlay = lawImportBEO.ImportOptions != ImportOptionsBEO.AppendNew;
}
if (profileBEO == null && lawImportBEO == null)
{
throw new EVException().AddDbgMsg("Unknown type of bootparameters: {0}", BootParameters);
}
vaultHelper = new VaultHelper(MatterId, CollectionId);
Tracer.Info(
"MatterId = {0}, CollectionId = {1}, VaultConnectionString = {2}, IsOverlay = {3}, ThreadsLinkingRequested = {4}, FamiliesLinkingRequested = {5}",
MatterId, CollectionId, vaultHelper.VaultConnectionString, IsOverlay, ThreadsLinkingRequested,
FamiliesLinkingRequested);
Dictionary <DocumentId, ExistingFamilyRecord> existingFamilies = null;
if (IsOverlay)
{
existingFamilies = vaultHelper.LoadExistingFamilies();
}
familiesProcessor = new FamiliesProcessor(IsOverlay, existingFamilies, isEDocsJob);
}
public ValuesController(IConfiguration configuration)
{
Configuration = configuration;
vh = new VaultHelper(Configuration["VaultURL"], Configuration["ClientId"], Configuration["ClientSecret"]);
//var secret = vh.GetSecret("myFirstSecret");
//secret.Wait();
}
protected override void BeginWork()
{
base.BeginWork();
var jobParameters = Utils.SmartXmlDeserializer(BootParameters);
var profileBEO = jobParameters as ProfileBEO;
if (profileBEO != null)
{
ThreadsLinkingRequested = profileBEO.IsMapEmailThread;
FamiliesLinkingRequested = profileBEO.IsImportFamilyRelations;
if (profileBEO.ImportTypeName.Contains("E-docs"))
{
ThreadsLinkingRequested = true;
FamiliesLinkingRequested = true;
}
CollectionId = profileBEO.DatasetDetails.CollectionId;
MatterId = profileBEO.DatasetDetails.Matter.FolderID;
IsOverlay = !profileBEO.IsAppend;
}
var lawImportBEO = jobParameters as LawImportBEO;
if (lawImportBEO != null)
{
ThreadsLinkingRequested = lawImportBEO.CreateThreads;
FamiliesLinkingRequested = lawImportBEO.CreateFamilyGroups;
CollectionId = lawImportBEO.CollectionId;
MatterId = lawImportBEO.MatterId;
IsOverlay = lawImportBEO.ImportOptions != ImportOptionsBEO.AppendNew;
}
if (profileBEO == null && lawImportBEO == null)
{
throw new EVException().AddDbgMsg("Unknown type of bootparameters: {0}", BootParameters);
}
vaultHelper = new VaultHelper(MatterId, CollectionId);
Tracer.Info(
"MatterId = {0}, CollectionId = {1}, VaultConnectionString = {2}, IsOverlay = {3}, ThreadsLinkingRequested = {4}, FamiliesLinkingRequested = {5}",
MatterId, CollectionId, vaultHelper.VaultConnectionString, IsOverlay, ThreadsLinkingRequested,
FamiliesLinkingRequested);
Dictionary<DocumentId, ExistingThreadRecord> existingThreads = null;
if (IsOverlay)
{
existingThreads = vaultHelper.LoadExistingThreads();
}
_threadsProcessor = new ThreadsProcessor(IsOverlay, existingThreads);
resultsAccumulator = new ThreadsCalculationResults();
}
public async Task CanGetMongoCreds()
{
var sut = await VaultHelper.CreateAsync(Config);
var secret = await sut.GetLiveSecretAsync("MongoDB", SecretGetters.MakeSecretTemplateGetter("mongodb://(vault://database/creds/mongodb-admin?template={{.username}}:{{.password}})@mongodb:27017/go-between?readPreference=primary"));
var firstValue = secret.Value;
firstValue.Should().NotBeEmpty();
firstValue.Should().MatchRegex(@"mongodb:\/\/[^:]+[^@]+@", "the username and password should be mapped in");
}
public void ShowWindowPdmTest()
{
string parentFilePath = @"C:\EPDMVaults\Training\Built Parts\Block1.sldprt";
string varName = "Document Number";
string vaultName = "Training";
IEdmVault13 vault = VaultSingleton.Instance;
VaultHelper h = new VaultHelper(vault);
string loginError;
if (!h.TryLoginAuto(vaultName, out loginError))
{
Assert.Fail();
}
IEdmFolder5 parentFolder;
IEdmFile5 file = (IEdmFile5)vault.GetFileFromPath(parentFilePath, out parentFolder);
var fileVars = (IEdmEnumeratorVariable10)file.GetEnumeratorVariable();
object oVal;
bool success = fileVars.GetVar2(varName, "@", parentFolder.ID, out oVal);
var window = new AAFileRefsWindow();
// do search and gret results...
var search = new VaultSearch(vault);
AAFileRef[] results = search.SearchForFileRefs(oVal.ToString());
var vm = new AAFileRefsViewModel(parentFilePath, results, () => window.Close());
window.DataContext = vm;
window.ShowDialog();
if (vm.OkWasClicked)
{
var fileRefsSvc = new CustomRefsService(vault);
string[] chilPaths = vm.Results
.Where(x => x.IsIncluded)
.Select(x => x.Path).ToArray();
fileRefsSvc.AddCustomReferences(file.ID, chilPaths);
}
}
public static void TestVault()
{
var vault = VaultHelper.GetVault(":user");
if (!vault.TestStorage())
{
try
{
vault.InitStorage();
}
catch
{
// ignored
}
}
}
public void ConfigureServices(IServiceCollection services, ILoggerFactory loggerFactory)
{
var serializationSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Formatting = Formatting.None
};
JsonConvert.DefaultSettings = () => serializationSettings;
using var vault = VaultHelper.CreateVaultClient(Configuration, loggerFactory);
services.AddHttpClient();
services.AddHealthChecks();
services.AddHostedService <Host>();
}
public async Task CanReadAndWriteThroughClient()
{
var sut = await VaultHelper.CreateAsync(Config);
var input = new Dictionary <string, object>
{
["a"] = "A",
["b"] = "B"
};
var path = "secret/data/test-secret";
await sut.WriteAsync <Dictionary <string, string> >(path, input);
var readActual = await sut.ReadAsync <Dictionary <string, string> >(path);
readActual.Data.Should().BeEquivalentTo(input);
}
public DirectContractsDbContext CreateDbContext(string[] args)
{
var configuration = new ConfigurationBuilder()
.SetBasePath(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location))
.AddJsonFile("appsettings.json",
false,
true)
.AddEnvironmentVariables()
.Build();
using var vaultClient = VaultHelper.CreateVaultClient(configuration);
vaultClient.Login(configuration[configuration["Vault:Token"]]).GetAwaiter().GetResult();
var connectionString = VaultHelper.GetDbConnectionString(vaultClient, "Database:ConnectionOptions", "Database:ConnectionString", configuration);
var dbContextOptions = new DbContextOptionsBuilder <DirectContractsDbContext>();
dbContextOptions.UseNpgsql(connectionString,
builder => builder.UseNetTopologySuite());
return(new DirectContractsDbContext(dbContextOptions.Options));
}
public async Task ClientRenewsOwnToken()
{
var helperWithOriginalToken = await VaultHelper.CreateAsync(Config);
var secret = await helperWithOriginalToken.WriteAsync <NoData>("auth/token/create", new Dictionary <string, string>()
{
["ttl"] = "1s",
["explicit_max_ttl"] = "1m",
["renewable"] = "true"
});
Exception ex = null;
Action <Exception> errorHandler = (e) => ex = e;
var sut = await VaultHelper.CreateAsync(new VaultHelperConfig(Config.Address)
.UsingTokenLogin(secret.Auth.ClientToken)
.WithErrorHandler(errorHandler));
await Task.Delay(TimeSpan.FromSeconds(1));
ex.Should().BeNull("the renewal should not have errored");
}
/// <summary>
///
/// </summary>
public AcmeSharpProvider(ILoggerInterface logger, string domain, EnvironmentSettings settings)
{
this.Settings = settings;
this.Logger = logger;
this.Domain = domain;
this.Logger.LogInfo(true, "Using ACME SHARP uri {0}", this.AcmeUri);
this.Vault = VaultHelper.GetVault(":user");
if (!this.Vault.TestStorage())
{
try
{
this.Vault.InitStorage();
}
catch
{
// ignored
}
}
}
static void Main()
{
IEdmVault13 vault = VaultSingleton.Instance;
VaultHelper vaultHelper = new VaultHelper(vault);
// everything below here is predicated on being logged in...
string error = null;
if (!vaultHelper.TryLoginAuto("Training", out error))
{
Debug.WriteLine(error);
}
else
{
// Login success (or EdmServer was already logged in)
var ex1 = new MapFolderExample();
ex1.MapFolder();
var ex2 = new MapFileReferenceExample();
ex2.MapFileReferenceWithVariableValues();
}
}
private static IVault GetVault()
{
return(VaultHelper.GetVault(null));
}
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers().SetJsonOptions();
using var vaultClient = VaultHelper.CreateVaultClient(Configuration);
vaultClient.Login(Configuration[Configuration["Vault:Token"]]).GetAwaiter().GetResult();
var dbConnectionString = VaultHelper.GetDbConnectionString(vaultClient, "DirectContracts:Database:ConnectionOptions", "DirectContracts:Database:ConnectionString", Configuration);
var redisEndpoint = Configuration[Configuration["Redis:Endpoint"]];
var amazonS3DocumentsOptions = VaultHelper.GetOptions(vaultClient, "DirectContracts:AmazonS3:Documents", Configuration);
var amazonS3ImagesOptions = VaultHelper.GetOptions(vaultClient, "DirectContracts:AmazonS3:Images", Configuration);
var mailSenderOptions = VaultHelper.GetOptions(vaultClient, "DirectContracts:Email", Configuration);
var bookingWebhookOptions = VaultHelper.GetOptions(vaultClient, "DirectContracts:BookingWebhookOptions", Configuration);
services.AddDirectContractsServices(dbConnectionString);
services.AddDirectManagerServices();
services.AddAmazonS3Client(options =>
{
options.AccessKeyId = amazonS3DocumentsOptions["accessKeyId"];
options.AccessKey = amazonS3DocumentsOptions["accessKey"];
options.AmazonS3Config = new AmazonS3Config
{
RegionEndpoint = RegionEndpoint.GetBySystemName(amazonS3DocumentsOptions["regionEndpoint"])
};
});
services.AddLocalization();
services.AddTracing(HostingEnvironment, Configuration);
services.AddOptions()
.Configure <RequestLocalizationOptions>(options =>
{
options.DefaultRequestCulture = new RequestCulture("en");
options.SupportedCultures = new[]
{
new CultureInfo("ar"),
new CultureInfo("en"),
new CultureInfo("ru")
};
options.RequestCultureProviders.Insert(0, new RouteDataRequestCultureProvider {
Options = options
});
})
.Configure <DocumentManagementServiceOptions>(options =>
{
options.AmazonS3Bucket = amazonS3DocumentsOptions["bucket"];
})
.Configure <ImageManagementServiceOptions>(options =>
{
options.AmazonS3Bucket = amazonS3ImagesOptions["bucket"];
options.AmazonS3RegionEndpoint = amazonS3ImagesOptions["regionEndpoint"];
})
.Configure <SenderOptions>(options =>
{
options.ApiKey = mailSenderOptions["apiKey"];
options.BaseUrl = new Uri(mailSenderOptions["publicUrl"]);
options.SenderAddress = new EmailAddress(mailSenderOptions["senderAddress"]);
})
.Configure <NotificationServiceOptions>(options =>
{
options.ManagerInvitationMessageTemplateId = mailSenderOptions["regularManagerInvitationTemplateId"];
options.ManagerRegistrationMessageTemplateId = mailSenderOptions["regularManagerRegistrationTemplateId"];
options.NewMasterManagerWelcomeMessageTemplateId = mailSenderOptions["newMasterManagerWelcomeTemplateId"];
})
.Configure <BookingWebhookOptions>(options =>
{
options.Key = bookingWebhookOptions["key"];
options.WebhookUrl = new Uri(bookingWebhookOptions["webhookUrl"]);
})
.Configure <ManagerInvitationOptions>(options =>
{
options.InvitationExpirationPeriod = TimeSpan.FromDays(7);
});
services.AddHealthChecks()
.AddCheck <ControllerResolveHealthCheck>(nameof(ControllerResolveHealthCheck))
.AddDbContextCheck <DirectContractsDbContext>()
.AddRedis(redisEndpoint);
services.AddApiVersioning(options =>
{
options.AssumeDefaultVersionWhenUnspecified = false;
options.DefaultApiVersion = new ApiVersion(1, 0);
options.ReportApiVersions = true;
});
services.AddResponseCompression()
.AddHttpContextAccessor()
.AddCors()
.AddLocalization()
.AddMemoryCache()
.AddStackExchangeRedisCache(options =>
{
options.Configuration = redisEndpoint;
})
.AddDoubleFlow()
.AddCacheFlowJsonSerialization();
services.AddHttpContextAccessor();
services.AddMvcCore(options =>
{
options.Conventions.Insert(0, new LocalizationConvention());
options.Conventions.Add(new AuthorizeControllerModelConvention());
options.Filters.Add(new MiddlewareFilterAttribute(typeof(LocalizationPipelineFilter)));
options.Filters.Add(typeof(ModelValidationFilter));
})
.AddAuthorization()
.AddControllersAsServices()
.AddFormatterMappings()
.AddApiExplorer()
.AddFluentValidation()
.SetCompatibilityVersion(CompatibilityVersion.Latest);
services.ConfigureAuthentication(Configuration, HostingEnvironment, vaultClient)
.ConfigureHttpClients(Configuration, HostingEnvironment, vaultClient)
.AddServices();
services.AddSwaggerGen(options =>
{
options.SwaggerDoc("v1.0", new OpenApiInfo {
Title = "HappyTravel.com Direct Contracts API", Version = "v1.0"
});
var xmlCommentsFileName = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlCommentsFilePath = Path.Combine(AppContext.BaseDirectory, xmlCommentsFileName);
options.CustomSchemaIds(t => t.FullName);
options.IncludeXmlComments(xmlCommentsFilePath);
options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey
});
options.AddSecurityRequirement(new OpenApiSecurityRequirement()
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
},
Scheme = "oauth2",
Name = "Bearer",
In = ParameterLocation.Header,
},
Array.Empty <string>()
}
});
});
services.AddSwaggerGenNewtonsoftSupport();
}