public override DataSource With(DataSourceOptions options)
{
Log.Enter(nameof(DataSourceOptions));
_options = options;
Log.Exit();
return(this);
}
public void CreateDefaultOptions()
{
BehaviorOptions = new BehaviorOptions();
DatabaseSchemaViewOptions = new DatabaseSchemaViewOptions();
DesignPaneOptions = new DesignPaneOptions();
VisualOptions = new VisualOptions();
AddObjectDialogOptions = new AddObjectDialogOptions();
DataSourceOptions = new DataSourceOptions();
QueryNavBarOptions = new QueryNavBarOptions();
UserInterfaceOptions = new UserInterfaceOptions();
SqlFormattingOptions = new SQLFormattingOptions();
SqlGenerationOptions = new SQLGenerationOptions();
}
public static ContainerBuilder RegisterFileReaderServices(this ContainerBuilder builder)
{
var url = new DataSourceOptions
{
urlSource = new Uri("file://C:/Users/st044618/Source/Repos/TextReader/TextReader/Data.txt")
};
builder.RegisterInstance(url);
builder.RegisterType <ConsoleWriter>().As <ITextWriter>();
builder.RegisterType <FileReader>().As <ITextReader>();
return(builder);
}
public static ContainerBuilder RegisterUrlReaderServices(this ContainerBuilder builder)
{
var url = new DataSourceOptions
{
urlSource = new Uri("https://timetable.spbu.ru/api/v1/addresses?seating=0&capacity=15")
};
builder.RegisterInstance(url);
builder.RegisterType <ConsoleWriter>().As <ITextWriter>();
builder.RegisterType <HttpReader>().As <ITextReader>();
return(builder);
}
public void Should_SerializeDataSourceOptions()
{
var options = new DataSourceOptions {
Buffer = 1,
Cluster = true,
ClusterMaxZoom = 3,
ClusterRadius = 4,
LineMetrics = true,
MaxZoom = 5,
Tolerance = 6
};
var expectedJson = JsonSerializer.Serialize(options, null);
TestAndAssertWrite(options, expectedJson);
}
public void SetOptions(Options options)
{
AddObjectDialogOptions.Assign(options.AddObjectDialogOptions);
BehaviorOptions.Assign(options.BehaviorOptions);
MainForm.DBView.Options.Assign(options.DatabaseSchemaViewOptions);
DataSourceOptions.Assign(options.DataSourceOptions);
DesignPaneOptions.Assign(options.DesignPaneOptions);
ExpressionEditorOptions.Assign(options.ExpressionEditorOptions);
QueryColumnListOptions.Assign(options.QueryColumnListOptions);
QueryNavBarOptions.Assign(options.QueryNavBarOptions);
SqlFormattingOptions.Assign(options.SqlFormattingOptions);
SqlGenerationOptions.Assign(options.SqlGenerationOptions);
TextEditorOptions.Assign(options.TextEditorOptions);
TextEditorSqlOptions.Assign(options.TextEditorSqlOptions);
UserInterfaceOptions.Assign(options.UserInterfaceOptions);
VisualOptions.Assign(options.VisualOptions);
}
/// <summary>
/// 获取数据来源的文字说明。
/// </summary>
/// <param name="dataSource">数据来源</param>
/// <returns>数据来源的文字说明</returns>
public static string GetDescription(this DataSourceOptions dataSource)
{
switch (dataSource)
{
case DataSourceOptions.None:
return("无");
case DataSourceOptions.Device:
return("采集");
case DataSourceOptions.Computing:
return("计算");
default:
throw new NotImplementedException("尚未实现该枚举。");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="KDatePickerConfiguration"/> class.
/// </summary>
public KDatePickerConfiguration()
{
// Base properties.
DataSource = new DataSourceOptions();
ControlWithKeyboardInsteadOfMouse = false;
// Current properties.
EnterValueAsText = false;
AnimationsEnabled = true;
AnimationDuration = TimeSpan.FromSeconds(1);
Depth = Depth.Month;
Min = null;
Max = null;
DateTimeFormats = new[] { "M/d/yyyy" };
DisabledDates = Array.Empty <DateTime>();
EnabledDates = Array.Empty <DateTime>();
Culture = CultureInfo.CreateSpecificCulture("en-US");
}
public void CreateDefaultOptions()
{
BehaviorOptions = new BehaviorOptions();
DatabaseSchemaViewOptions = new DatabaseSchemaViewOptions();
DesignPaneOptions = new DesignPaneOptions();
VisualOptions = new VisualOptions();
AddObjectDialogOptions = new AddObjectDialogOptions();
DataSourceOptions = new DataSourceOptions();
QueryNavBarOptions = new QueryNavBarOptions();
UserInterfaceOptions = new UserInterfaceOptions();
SqlFormattingOptions = new SQLFormattingOptions();
SqlGenerationOptions = new SQLGenerationOptions();
ExpressionEditorOptions = new ExpressionEditorOptions();
TextEditorOptions = new TextEditorOptions
{
Padding = DefaultTextEditorPadding,
LineHeight = new LengthUnit(90, SizeUnitType.Percent)
};
TextEditorSqlOptions = new SqlTextEditorOptions();
}
public AuditTarget(Dictionary <string, object> audit_options, EventHandler <EnvironmentEventArgs> controller_message_handler = null)
{
if (ReferenceEquals(audit_options, null))
{
throw new ArgumentNullException("audit_options");
}
this.AuditOptions = audit_options;
#region Setup host environment
if (this.AuditOptions.ContainsKey("HostEnvironment"))
{
this.HostEnvironment = (LocalEnvironment)this.AuditOptions["HostEnvironment"];
this.HostEnvironmentInitialised = true;
}
else
{
this.ControllerMessage = controller_message_handler;
this.HostEnvironmentMessage = AuditTarget_HostEnvironmentMessageHandler;
this.HostEnvironment = new LocalEnvironment(this.HostEnvironmentMessage);
this.HostEnvironment.ScriptEnvironment.MessageHandler += this.AuditTarget_ScriptEnvironmentMessageHandler;
if (this.AuditOptions.ContainsKey("Dockerized"))
{
this.HostEnvironment.IsDockerContainer = true;
}
this.HostEnvironmentInitialised = true;
}
#endregion
#region Setup audit environment
if (this.AuditOptions.ContainsKey("AuditEnvironment"))
{
this.AuditEnvironment = (AuditEnvironment)this.AuditOptions["AuditEnvironment"];
this.AuditEnvironmentIntialised = true;
}
else
{
if (this.AuditOptions.Keys.Contains("DockerContainer") && !this.AuditOptions.Keys.Contains("RemoteHost"))
{
DockerAuditEnvironment docker_environment = new DockerAuditEnvironment(this.HostEnvironmentMessage, (string)this.AuditOptions["DockerContainer"], new OperatingSystem(PlatformID.Unix, new Version(0, 0)), this.HostEnvironment);
if (string.IsNullOrEmpty(docker_environment.Container))
{
this.AuditEnvironmentIntialised = false;
throw new Exception("Failed to initialise audit environment.");
}
else if (!docker_environment.ContainerRunning)
{
this.AuditEnvironmentIntialised = false;
throw new Exception("The Docker container is not currently running and DevAudit does not know how to run your container. Ensure your container is running before attempting to" +
"audit it.");
}
else
{
this.AuditEnvironment = docker_environment;
this.AuditEnvironmentIntialised = true;
this.AuditEnvironmentMessage = AuditTarget_AuditEnvironmentMessageHandler;
this.AuditEnvironment.MessageHandler -= HostEnvironmentMessage;
this.AuditEnvironment.MessageHandler += this.AuditEnvironmentMessage;
}
}
else if (this.AuditOptions.Keys.Contains("DockerContainer") && this.AuditOptions.Keys.Contains("RemoteHost"))
{
SshDockerAuditEnvironment ssh_environment = null;
if (this.AuditOptions.Keys.Contains("RemoteUser") && this.AuditOptions.Keys.Contains("RemoteKeyFile"))
{
if (this.AuditOptions.Keys.Contains("RemoteKeyPassPhrase"))
{
ssh_environment = new SshDockerAuditEnvironment(this.HostEnvironmentMessage, "ssh", (string)this.AuditOptions["RemoteHost"], (int)this.AuditOptions["RemoteSshPort"],
(string)this.AuditOptions["RemoteUser"], this.AuditOptions["RemoteKeyPassPhrase"], (string)this.AuditOptions["RemoteKeyFile"],
(string)this.AuditOptions["DockerContainer"], new OperatingSystem(PlatformID.Unix, new Version(0, 0)), this.HostEnvironment);
}
else
{
ssh_environment = new SshDockerAuditEnvironment(this.HostEnvironmentMessage, "ssh", (string)this.AuditOptions["RemoteHost"], (int)this.AuditOptions["RemoteSshPort"],
(string)this.AuditOptions["RemoteUser"], null, (string)this.AuditOptions["RemoteKeyFile"],
(string)this.AuditOptions["DockerContainer"], new OperatingSystem(PlatformID.Unix, new Version(0, 0)), this.HostEnvironment);
}
}
else if (this.AuditOptions.Keys.Contains("RemoteUser") && this.AuditOptions.Keys.Contains("RemotePass"))
{
ssh_environment = new SshDockerAuditEnvironment(this.HostEnvironmentMessage, "ssh", (string)this.AuditOptions["RemoteHost"], (int)this.AuditOptions["RemoteSshPort"],
(string)this.AuditOptions["RemoteUser"], this.AuditOptions["RemotePass"], null, (string)this.AuditOptions["DockerContainer"], new OperatingSystem(PlatformID.Unix, new Version(0, 0)), this.HostEnvironment);
}
else
{
throw new Exception("Unknown remote host authentication options.");
}
if (ssh_environment.IsConnected)
{
if (string.IsNullOrEmpty(ssh_environment.Container))
{
this.AuditEnvironmentIntialised = false;
throw new Exception("Failed to initialise audit environment.");
}
else if (!ssh_environment.ContainerRunning)
{
this.AuditEnvironmentIntialised = false;
throw new Exception("The Docker container is not currently running and DevAudit does not know how to run your container. Ensure your container is running before attempting to" +
"audit it.");
}
else
{
this.AuditEnvironment = ssh_environment;
this.AuditEnvironmentIntialised = true;
this.AuditEnvironmentMessage = AuditTarget_AuditEnvironmentMessageHandler;
this.AuditEnvironment.MessageHandler -= HostEnvironmentMessage;
this.AuditEnvironment.MessageHandler += this.AuditEnvironmentMessage;
}
}
else
{
ssh_environment = null;
this.AuditEnvironmentIntialised = false;
throw new Exception("Failed to initialise SSH Docker audit environment.");
}
}
else if (this.AuditOptions.Keys.Contains("RemoteHost"))
{
string client;
SshAuditEnvironment ssh_environment = null;
if (this.HostEnvironment.OS.Platform == PlatformID.Win32NT)
{
client = this.AuditOptions.Keys.Contains("WindowsUsePlink") ? "plink" : this.AuditOptions.Keys.Contains("WindowsUsePlink") ? "openssh" : "ssh";
}
else
{
client = "ssh";
}
if (this.AuditOptions.Keys.Contains("RemoteUser") && this.AuditOptions.Keys.Contains("RemoteKeyFile"))
{
if (this.AuditOptions.Keys.Contains("RemoteKeyPassPhrase"))
{
ssh_environment = new SshAuditEnvironment(this.HostEnvironmentMessage, client, (string)this.AuditOptions["RemoteHost"], (int)this.AuditOptions["RemoteSshPort"],
(string)this.AuditOptions["RemoteUser"], this.AuditOptions["RemoteKeyPassPhrase"], (string)this.AuditOptions["RemoteKeyFile"], new OperatingSystem(PlatformID.Unix, new Version(0, 0)), this.HostEnvironment);
}
else
{
ssh_environment = new SshAuditEnvironment(this.HostEnvironmentMessage, client, (string)this.AuditOptions["RemoteHost"], (int)this.AuditOptions["RemoteSshPort"],
(string)this.AuditOptions["RemoteUser"], null, (string)this.AuditOptions["RemoteKeyFile"], new OperatingSystem(PlatformID.Unix, new Version(0, 0)), this.HostEnvironment);
}
}
else if (this.AuditOptions.Keys.Contains("RemoteUser") && this.AuditOptions.Keys.Contains("RemotePass"))
{
ssh_environment = new SshAuditEnvironment(this.HostEnvironmentMessage, client, (string)this.AuditOptions["RemoteHost"], (int)this.AuditOptions["RemoteSshPort"],
(string)this.AuditOptions["RemoteUser"], this.AuditOptions["RemotePass"], null, new OperatingSystem(PlatformID.Unix, new Version(0, 0)), this.HostEnvironment);
}
else
{
throw new Exception("Unknown remote host authentication options.");
}
if (ssh_environment.IsConnected)
{
this.AuditEnvironment = ssh_environment;
this.AuditEnvironmentIntialised = true;
this.AuditEnvironmentMessage = AuditTarget_AuditEnvironmentMessageHandler;
this.AuditEnvironment.MessageHandler -= HostEnvironmentMessage;
this.AuditEnvironment.MessageHandler += this.AuditEnvironmentMessage;
}
else
{
ssh_environment = null;
this.AuditEnvironmentIntialised = false;
throw new Exception("Failed to initialise SSH audit environment.");
}
}
else if (this.AuditOptions.Keys.Contains("WinRmRemoteIp") || this.AuditOptions.Keys.Contains("WinRmRemoteHost"))
{
if (!this.AuditOptions.Keys.Contains("RemoteUser") || !this.AuditOptions.Keys.Contains("RemotePass"))
{
throw new Exception("A remote user and password must be specified.");
}
WinRmAuditEnvironment winrm;
if (this.AuditOptions.Keys.Contains("WinRmRemoteIp"))
{
winrm = new WinRmAuditEnvironment(this.HostEnvironmentMessage, this.AuditOptions["WinRmRemoteIp"] as IPAddress,
(string)this.AuditOptions["RemoteUser"], (SecureString)this.AuditOptions["RemotePass"], this.HostEnvironment);
if (winrm.IsConnected)
{
this.AuditEnvironment = winrm;
this.AuditEnvironmentIntialised = true;
this.AuditEnvironmentMessage = AuditTarget_AuditEnvironmentMessageHandler;
this.AuditEnvironment.MessageHandler -= HostEnvironmentMessage;
this.AuditEnvironment.MessageHandler += this.AuditEnvironmentMessage;
}
else
{
winrm = null;
this.AuditEnvironmentIntialised = false;
throw new Exception("Failed to initialise WinRM audit environment.");
}
}
else
{
winrm = new WinRmAuditEnvironment(this.HostEnvironmentMessage, (string)this.AuditOptions["WinRmRemoteHost"],
(string)this.AuditOptions["RemoteUser"], (SecureString)this.AuditOptions["RemotePass"], this.HostEnvironment);
}
}
else if (this.AuditOptions.Keys.Contains("RemoteUser") || this.AuditOptions.Keys.Contains("RemotePass"))
{
throw new Exception("A remote host name must be specified.");
}
else if (this.AuditOptions.ContainsKey("Dockerized"))
{
this.AuditEnvironmentMessage = AuditTarget_AuditEnvironmentMessageHandler;
this.AuditEnvironment = new DockerizedLocalEnvironment(this.AuditEnvironmentMessage);
this.AuditEnvironmentIntialised = true;
}
else if (this.AuditOptions.ContainsKey("GitHubRepoName"))
{
if (!this.AuditOptions.ContainsKey("GitHubRepoOwner") || !this.AuditOptions.ContainsKey("GitHubRepoBranch"))
{
throw new ArgumentException("A required audit option for the GitHub environment is missing.");
}
string user_api_token = string.Empty;
if (this.AuditOptions.ContainsKey("GitHubToken"))
{
user_api_token = (string)this.AuditOptions["GitHubToken"];
}
GitHubAuditEnvironment github_environment = new GitHubAuditEnvironment(this.HostEnvironmentMessage, user_api_token, (string)this.AuditOptions["GitHubRepoOwner"],
(string)this.AuditOptions["GitHubRepoName"], (string)this.AuditOptions["GitHubRepoBranch"], this.HostEnvironment);
if (github_environment.RepositoryInitialised)
{
this.AuditEnvironment = github_environment;
this.AuditEnvironmentIntialised = true;
this.AuditEnvironmentMessage = AuditTarget_AuditEnvironmentMessageHandler;
this.AuditEnvironment.MessageHandler -= HostEnvironmentMessage;
this.AuditEnvironment.MessageHandler += this.AuditEnvironmentMessage;
}
else
{
github_environment = null;
this.AuditEnvironmentIntialised = false;
throw new Exception("Failed to initialise GitHub audit environment.");
}
}
else if (this.AuditOptions.ContainsKey("GitLabRepoName"))
{
string api_token = string.Empty;
if (!this.AuditOptions.ContainsKey("GitLabRepoUrl") || !this.AuditOptions.ContainsKey("GitLabRepoName") || !this.AuditOptions.ContainsKey("GitLabRepoBranch"))
{
throw new ArgumentException("A required audit option for the GitLab environment is missing.");
}
GitLabAuditEnvironment GitLab_environment = new GitLabAuditEnvironment(this.HostEnvironmentMessage, api_token, (string)this.AuditOptions["GitLabRepoUrl"],
(string)this.AuditOptions["GitLabRepoName"], (string)this.AuditOptions["GitLabRepoBranch"], this.HostEnvironment);
if (GitLab_environment.RepositoryInitialised)
{
this.AuditEnvironment = GitLab_environment;
this.AuditEnvironmentIntialised = true;
this.AuditEnvironmentMessage = AuditTarget_AuditEnvironmentMessageHandler;
this.AuditEnvironment.MessageHandler -= HostEnvironmentMessage;
this.AuditEnvironment.MessageHandler += this.AuditEnvironmentMessage;
}
else
{
GitLab_environment = null;
this.AuditEnvironmentIntialised = false;
throw new Exception("Failed to initialise audit environment.");
}
}
else
{
this.AuditEnvironmentMessage = AuditTarget_AuditEnvironmentMessageHandler;
this.AuditEnvironment = new LocalEnvironment(this.AuditEnvironmentMessage);
this.AuditEnvironmentIntialised = true;
}
if (this.AuditOptions.ContainsKey("Profile"))
{
AuditFileInfo pf = this.AuditEnvironment.ConstructFile((string)this.AuditOptions["Profile"]);
if (pf.Exists)
{
this.AuditProfile = new AuditProfile(this.AuditEnvironment, pf);
}
else
{
this.AuditEnvironment.Warning("The profile file {0} does not exist. No audit profile will be used.", pf.FullName);
}
}
if (this.AuditEnvironment is IOperatingSystemEnvironment)
{
this.AuditEnvironment.GetOSName();
this.AuditEnvironment.GetOSVersion();
if (this.AuditOptions.ContainsKey("OSName"))
{
this.AuditEnvironment.OSName = (string)this.AuditOptions["OSName"];
this.AuditEnvironment.Info("Overriding audit environment OS name to {0}.", this.AuditEnvironment.OSName);
}
if (this.AuditOptions.ContainsKey("OSVersion"))
{
this.AuditEnvironment.OSVersion = (string)this.AuditOptions["OSVersion"];
this.AuditEnvironment.Info("Overriding audit environment OS version to {0}.", this.AuditEnvironment.OSVersion);
}
}
}
#endregion
#region Setup data source options
if (this.AuditOptions.ContainsKey("NoCache"))
{
this.DataSourceOptions.Add("NoCache", true);
}
if (this.AuditOptions.ContainsKey("DeleteCache"))
{
this.DataSourceOptions.Add("DeleteCache", true);
}
if (this.AuditOptions.ContainsKey("HttpsProxy"))
{
DataSourceOptions.Add("HttpsProxy", (Uri)this.AuditOptions["HttpsProxy"]);
}
if (this.AuditOptions.ContainsKey("IgnoreHttpsCertErrors"))
{
this.DataSourceOptions.Add("IgnoreHttpsCertErrors", true);
}
if (this.AuditOptions.ContainsKey("ApiUser"))
{
this.DataSourceOptions.Add("ApiUser", this.AuditOptions["ApiUser"]);
}
else if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("API_USER")))
{
this.DataSourceOptions.Add("ApiUser", Environment.GetEnvironmentVariable("API_USER"));
}
if (this.AuditOptions.ContainsKey("ApiToken"))
{
this.DataSourceOptions.Add("ApiToken", this.AuditOptions["ApiToken"]);
}
else if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("API_TOKEN")))
{
this.DataSourceOptions.Add("ApiToken", Environment.GetEnvironmentVariable("API_TOKEN"));
}
if (this.AuditOptions.ContainsKey("WithOSSI"))
{
this.DataSources.Add(new OSSIndexApiv3DataSource(this, DataSourceOptions));
}
if (this.AuditOptions.ContainsKey("WithVulners"))
{
this.DataSources.Add(new VulnersDataSource(this, DataSourceOptions));
}
#endregion
#region Setup audit profile
if (this.AuditEnvironment.FileExists("devaudit.yml"))
{
this.AuditProfile = new AuditProfile(this.AuditEnvironment, this.AuditEnvironment.ConstructFile("devaudit.yml"));
}
#endregion
}
public DataSource(DataSourceOptions options) : base(options)
{
}
public PackageSource(Dictionary <string, object> package_source_options, EventHandler <EnvironmentEventArgs> message_handler) : base(package_source_options, message_handler)
{
this.PackageSourceOptions = this.AuditOptions;
if (this.PackageSourceOptions.ContainsKey("File"))
{
this.PackageManagerConfigurationFile = (string)this.PackageSourceOptions["File"];
if (!this.AuditEnvironment.FileExists(this.PackageManagerConfigurationFile))
{
throw new ArgumentException("Could not find the file " + this.PackageManagerConfigurationFile + ".", "package_source_options");
}
}
else if (!this.PackageSourceOptions.ContainsKey("File") && this.DefaultPackageManagerConfigurationFile != string.Empty)
{
if (this.AuditEnvironment.FileExists(this.DefaultPackageManagerConfigurationFile))
{
this.AuditEnvironment.Info("Using default {0} package manager configuration file {1}", this.PackageManagerLabel, this.DefaultPackageManagerConfigurationFile);
this.PackageManagerConfigurationFile = this.DefaultPackageManagerConfigurationFile;
}
else
{
throw new ArgumentException(string.Format("No file option was specified and the default {0} package manager configuration file {1} was not found.", this.PackageManagerLabel, this.DefaultPackageManagerConfigurationFile));
}
}
if (!string.IsNullOrEmpty(this.PackageManagerConfigurationFile))
{
AuditFileInfo cf = this.AuditEnvironment.ConstructFile(this.PackageManagerConfigurationFile);
AuditDirectoryInfo d = this.AuditEnvironment.ConstructDirectory(cf.DirectoryName);
IFileInfo[] pf;
if ((pf = d.GetFiles("devaudit.yml")) != null)
{
this.AuditProfile = new AuditProfile(this.AuditEnvironment, this.AuditEnvironment.ConstructFile(pf.First().FullName));
}
}
if (this.PackageSourceOptions.ContainsKey("ListPackages"))
{
this.ListPackages = true;
}
if (this.PackageSourceOptions.ContainsKey("ListArtifacts"))
{
this.ListArtifacts = true;
}
if (this.PackageSourceOptions.ContainsKey("SkipPackagesAudit"))
{
this.SkipPackagesAudit = true;
}
if (this.PackageSourceOptions.ContainsKey("WithPackageInfo"))
{
this.WithPackageInfo = true;
}
if (this.PackageSourceOptions.ContainsKey("HttpsProxy"))
{
if (this.AuditOptions.ContainsKey("HttpsProxy"))
{
DataSourceOptions.Add("HttpsProxy", (Uri)this.PackageSourceOptions["HttpsProxy"]);
}
}
string[] ossi_pms = { "bower", "composer", "choco", "msi", "nuget", "oneget", "yarn" };
if (this.DataSources.Count == 0 && ossi_pms.Contains(this.PackageManagerId))
{
this.HostEnvironment.Info("Using OSS Index as default package vulnerabilities data source for {0} package source.", this.PackageManagerLabel);
this.DataSources.Add(new OSSIndexDataSource(this, this.DataSourceOptions));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseKendoConfiguration"/> class.
/// </summary>
public BaseKendoConfiguration()
{
ControlWithKeyboardInsteadOfMouse = false;
DataSource = new DataSourceOptions();
}
public RepositoryBase(IEnumerable <IContext> contents, DataSourceOptions datasource)
{
DbContext = contents.FirstOrDefault(p => p.DataSourceOptions == datasource);
}
public IUnitOfWork Create(DataSourceOptions datasource)
{
var context = _contexts.FirstOrDefault(p => p.DataSourceOptions == datasource);
return(new UnitOfWork(context));
}
