public DefaultMigrationInformationLoader(IMigrationRunnerConventions conventions, IAssemblyCollection assemblies, string @namespace,
bool loadNestedNamespaces, IEnumerable <string> tagsToMatch)
{
Conventions = conventions;
Assemblies = assemblies;
Namespace = @namespace;
LoadNestedNamespaces = loadNestedNamespaces;
_tagsToMatch = tagsToMatch as IReadOnlyCollection <string> ?? tagsToMatch?.ToArray() ?? Array.Empty <string>();
_source = new MigrationSource(new AssemblySource(() => assemblies), conventions);
}
public AggregateMigrationInfoLoader(
IMigrationContext migrationContext,
IMigrationSource source,
IOptionsSnapshot <TypeFilterOptions> filterOptions,
IMigrationRunnerConventions conventions,
IOptions <RunnerOptions> runnerOptions)
: base(source, filterOptions, conventions, runnerOptions)
{
this.myMigrationContext = migrationContext;
}
public DefaultMigrationInformationLoader(
[NotNull] IMigrationSource source,
[NotNull] IOptions <TypeFilterOptions> filterOptions,
[NotNull] IMigrationRunnerConventions conventions,
[NotNull] IOptions <RunnerOptions> runnerOptions)
{
_source = source;
Namespace = filterOptions.Value.Namespace;
LoadNestedNamespaces = filterOptions.Value.NestedNamespaces;
Conventions = conventions;
_tagsToMatch = runnerOptions.Value.Tags ?? Array.Empty <string>();
}
private static IEnumerable <IMigrationInfo> FindMigrations(
#pragma warning disable 618
[NotNull] IMigrationSource source,
#pragma warning restore 618
[NotNull] IMigrationRunnerConventions conventions,
[CanBeNull] string @namespace,
bool loadNestedNamespaces,
[NotNull, ItemNotNull] IReadOnlyCollection <string> tagsToMatch)
{
bool IsMatchingMigration(Type type)
{
if (!type.IsInNamespace(@namespace, loadNestedNamespaces))
{
return(false);
}
if (!conventions.TypeIsMigration(type))
{
return(false);
}
return(conventions.TypeHasMatchingTags(type, tagsToMatch) ||
(tagsToMatch.Count == 0 && !conventions.TypeHasTags(type)) ||
!conventions.TypeHasTags(type));
}
IReadOnlyCollection <IMigration> migrations;
if (source is IFilteringMigrationSource filteringSource)
{
migrations = filteringSource.GetMigrations(IsMatchingMigration).ToList();
}
else
{
migrations =
(from migration in source.GetMigrations()
where IsMatchingMigration(migration.GetType())
select migration).ToList();
}
if (migrations.Count == 0)
{
throw new MissingMigrationsException("No migrations found");
}
var migrationInfos = migrations
.Select(conventions.GetMigrationInfoForMigration)
.ToList();
return(migrationInfos);
}
public DefaultMigrationInformationLoader(
#pragma warning disable 618
[NotNull] IMigrationSource source,
#pragma warning restore 618
[NotNull] IOptionsSnapshot <TypeFilterOptions> filterOptions,
[NotNull] IMigrationRunnerConventions conventions,
[NotNull] IOptions <RunnerOptions> runnerOptions)
{
_source = source;
Namespace = filterOptions.Value.Namespace;
LoadNestedNamespaces = filterOptions.Value.NestedNamespaces;
Conventions = conventions;
_tagsToMatch = runnerOptions.Value.Tags ?? Array.Empty <string>();
_includeUntaggedMigrations = runnerOptions.Value.IncludeUntaggedMigrations;
}
private static IEnumerable <IMigrationInfo> FindMigrations(
[NotNull] IMigrationSource source,
[NotNull] IMigrationRunnerConventions conventions,
[CanBeNull] string @namespace,
bool loadNestedNamespaces,
[NotNull, ItemNotNull] IReadOnlyCollection <string> tagsToMatch)
{
var migrations = source.GetMigrations().ToList();
if (migrations.Count == 0)
{
throw new MissingMigrationsException("No migrations found");
}
var migrationInfos =
(from migration in migrations
let type = migration.GetType()
where type.IsInNamespace(@namespace, loadNestedNamespaces)
where conventions.TypeHasMatchingTags(type, tagsToMatch) || (tagsToMatch.Count == 0 && !conventions.TypeHasTags(type)) || !conventions.TypeHasTags(type)
select conventions.GetMigrationInfoForMigration(migration));
return(migrationInfos.ToList());
}
