public EntityFrameworkCoreDependencyInjectionDecorator(DependencyInjectionTemplate template, IApplication application)
{
_template = template;
_application = application;
_template.AddNugetDependency(NugetPackages.EntityFrameworkCoreSqlServer(_template.Project));
_template.AddNugetDependency(NugetPackages.EntityFrameworkCoreInMemory(_template.Project));
if (_template.Project.IsNet5App())
{
_template.AddNugetDependency("Microsoft.Extensions.Configuration.Binder", "5.0.0");
}
if (_template.Project.IsNet6App())
{
_template.AddNugetDependency("Microsoft.Extensions.Configuration.Binder", "6.0.0");
}
if (_template.ExecutionContext.Settings.GetMultitenancySettings()?.DataIsolation().IsSeparateDatabases() == true)
{
_template.AddNugetDependency("Finbuckle.MultiTenant", "6.5.1");
}
_template.ExecutionContext.EventDispatcher.Publish(new AppSettingRegistrationRequest(
key: "UseInMemoryDatabase",
value: "true"));
_template.ExecutionContext.EventDispatcher.Publish(new ConnectionStringRegistrationRequest(
name: "DefaultConnection",
connectionString: $"Server=.;Initial Catalog={ _template.OutputTarget.Application.Name };Integrated Security=true;MultipleActiveResultSets=True",
providerName: "System.Data.SqlClient"));
}
public DbContextInterfaceTemplate(IOutputTarget outputTarget, IList <ClassModel> model) : base(Identifier, outputTarget, model)
{
AddNugetDependency(NugetPackages.EntityFrameworkCore(Project));
ExecutionContext.EventDispatcher.Subscribe <EntityTypeConfigurationCreatedEvent>(evt =>
{
_entityTypeConfigurations.Add(evt);
});
}
public IEnumerable <INugetPackageInfo> GetNugetDependencies()
{
return(new INugetPackageInfo[]
{
NugetPackages.IdentityServer4EntityFramework,
NugetPackages.MicrosoftAspNetCoreIdentityEntityFrameworkCore(_template.OutputTarget.GetProject())
});
}
public IEnumerable <INugetPackageInfo> GetNugetDependencies()
{
return(new[]
{
NugetPackages.EntityFrameworkCoreDesign(OutputTarget),
NugetPackages.EntityFrameworkCoreTools(OutputTarget),
}
.ToArray());
}
public void Test_Get_Project_Asset_Nugets()
{
var path = Path.Combine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "TestData");
var packageVersions = new Dictionary <string, string>();
NugetPackages.GatherProjectJsonVersions(
VerifyVersionsTask.AndroidXPackagePrefix,
path,
VerifyVersionsTask.ExcludedAndroidXPackages,
new Version(8, 1),
packageVersions);
Assert.NotEmpty(packageVersions);
}
public override IEnumerable <INugetPackageInfo> GetNugetDependencies()
{
return((UseLazyLoadingProxies
? new[]
{
NugetPackages.EntityFrameworkCore(Project),
NugetPackages.EntityFrameworkCoreProxies(Project),
}
: new[]
{
NugetPackages.EntityFrameworkCore(Project),
})
.Union(base.GetNugetDependencies())
.ToArray());
}
public void Test_Should_Detect_Multiple_Versions_Project_Assets()
{
var path = Path.Combine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "TestData");
var packageVersions = new Dictionary <string, string>();
NugetPackages.GatherProjectJsonVersions(
VerifyVersionsTask.PACKAGE_ID_PREFIX,
path,
VerifyVersionsTask.ExcludedPackages,
new Version(8, 1),
packageVersions);
Assert.NotEmpty(packageVersions);
var distinctVersions = NugetPackages.GetDistinctVersions(VerifyVersionsTask.PACKAGE_ID_PREFIX, VerifyVersionsTask.ExcludedPackages, packageVersions);
Assert.True(distinctVersions > 1);
}
public async Task GetDefaultVersion()
{
var version = "0.0.1101.3104-alpha";
var nuVersion = NuGetVersion.Parse(version);
var versions = new string[]
{
$"Microsoft.Quantum.Standard::{version}",
$"Microsoft.Quantum.Quantum.Development.Kit::{version}",
$"Microsoft.Quantum.Chemistry::{version}"
};
var mgr = new NugetPackages(new MockNugetOptions(versions), null);
Assert.AreEqual(nuVersion, await mgr.GetLatestVersion("Microsoft.Quantum.Standard"));
Assert.AreEqual(nuVersion, await mgr.GetLatestVersion("Microsoft.Quantum.Chemistry"));
Assert.AreEqual(nuVersion, await mgr.GetLatestVersion("microsoft.quantum.chemistry"));
Assert.AreEqual(nuVersion, await mgr.GetLatestVersion(" microsoft.quantum.chemistry "));
Assert.AreNotEqual(nuVersion, await mgr.GetLatestVersion("Microsoft.Quantum.Research"));
}
public override bool Execute()
{
Log.LogMessage("ProjectPath: {0}", ProjectPath.ItemSpec);
Log.LogMessage("ProjectExtensionsPath: {0}", ProjectExtensionsPath.ItemSpec);
Log.LogMessage("TargetFrameworkVersion: {0}", TargetFrameworkVersion.ItemSpec);
var frameworkVersion = Version.Parse(TargetFrameworkVersion.ItemSpec.ToLowerInvariant().TrimStart('v'));
var apiLevel = NugetPackages.GetMajorVersion(TargetApiLevel.ItemSpec);
var buildToolsApiLevel = NugetPackages.GetMajorVersion(AndroidSdkBuildToolsVersion.ItemSpec);
Log.LogMessage("TargetApiLevel: {0}", apiLevel);
Log.LogMessage("FrameworkVersion: {0}", frameworkVersion);
Log.LogMessage("AndroidSdkBuildToolsApiLevel: {0}", buildToolsApiLevel);
if (File.Exists(Path.Combine(ProjectPath.ItemSpec, "packages.config")))
{
Log.LogMessage("PackageReferenceType: packages.config");
NugetPackages.GatherPackagesConfigVersions("xamarin.androidx.", ProjectPath.ItemSpec, ExcludedAndroidXPackages, androidxPackages);
NugetPackages.GatherPackagesConfigVersions("xamarin.android.support.", ProjectPath.ItemSpec, ExcludedAndroidSupportPackages, androidSupportPackages);
}
else
{
Log.LogMessage("PackageReferenceType: PackageReference");
NugetPackages.GatherProjectJsonVersions("xamarin.androidx.", ProjectExtensionsPath.ItemSpec, ExcludedAndroidXPackages, frameworkVersion, androidxPackages, Log);
NugetPackages.GatherProjectJsonVersions("xamarin.android.support.", ProjectExtensionsPath.ItemSpec, ExcludedAndroidSupportPackages, frameworkVersion, androidSupportPackages, Log);
}
foreach (var pair in androidxPackages)
{
Log.LogMessage("Referenced AndroidX Package: {0} ({1})", pair.Key, pair.Value);
}
/*
* In the future we may add some logic to detect if certain Android Support packages
* are referenced in the project but their equivalent AndroidX packages are not
*/
return(true);
}
public async Task Test_Recommended_NuGet_Version(int apiLevel, string expectedVersion)
{
var v = await NugetPackages.GetRecommendedSupportPackageVersion(apiLevel);
Assert.Equal(expectedVersion, v);
}
public void Test_Recommended_NuGet_Version(int apiLevel, string expectedVersion)
{
var v = NugetPackages.GetRecommendedSupportPackageVersion(apiLevel, false);
Assert.Equal(expectedVersion, v);
}
public EntityTypeConfigurationTemplate(IOutputTarget outputTarget, ClassModel model) : base(TemplateId, outputTarget, model)
{
_explicitPrimaryKeys = Model.Attributes.Where(x => x.HasPrimaryKey()).ToList();
AddNugetDependency(NugetPackages.EntityFrameworkCore(Project));
AddNugetDependency(NugetPackages.EntityFrameworkCoreSqlServer(Project));
}
public Project WithNugetPackage(NugetPackage nugetPackage)
{
NugetPackages.Add(nugetPackage);
return(this);
}
