public InstanceContextFilter(InstanceContext instanceContext, AdminAppDbContext adminAppDbContext,
AdminAppIdentityDbContext adminAppIdentityDbContext)
{
_instanceContext = instanceContext;
_adminAppDbContext = adminAppDbContext;
_adminAppIdentityDbContext = adminAppIdentityDbContext;
}
private async Task WriteSecretConfiguration(OdsSecretConfiguration configuration, int?instanceRegistrationId)
{
var stringValue = Json.Encode(configuration);
var encryptedValue = _stringEncryptorService.Encrypt(stringValue);
using (var database = new AdminAppDbContext())
{
var secretConfiguration =
await database.SecretConfigurations.SingleOrDefaultAsync(x =>
x.OdsInstanceRegistrationId == instanceRegistrationId);
if (secretConfiguration == null)
{
database.SecretConfigurations.Add(new SecretConfiguration
{
EncryptedData = encryptedValue, OdsInstanceRegistrationId = instanceRegistrationId
});
}
else
{
secretConfiguration.EncryptedData = encryptedValue;
}
await database.SaveChangesAsync();
}
}
public static void ResetOdsInstanceRegistrations()
{
using (var dbContext = new AdminAppDbContext())
{
dbContext.Database.ExecuteSqlCommand("DELETE FROM [adminapp].[OdsInstanceRegistrations]");
}
}
public static void ResetUsers()
{
using (var dbContext = new AdminAppDbContext())
{
dbContext.Database.ExecuteSqlCommand("DELETE FROM [adminapp].[Users]");
}
}
public static void Save <TEntity>(List <TEntity> values) where TEntity : Entity
{
using (var database = new AdminAppDbContext())
{
database.Set <TEntity>().AddRange(values);
database.SaveChanges();
}
}
public SetupRequiredFilter(IGetOdsStatusQuery getOdsStatusQuery
, AdminAppDbContext database
)
{
_getOdsStatusQuery = getOdsStatusQuery;
_database = database;
}
public EditOdsInstanceRegistrationForUserModelValidator(AdminAppDbContext database)
{
_database = database;
RuleFor(m => m.UserId).NotEmpty().Must(BeAnExistingUser).WithMessage("The user you are trying to edit does not exist in the database.");
RuleFor(m => m.Email).NotEmpty();
RuleFor(m => m.OdsInstanceRegistrations).NotEmpty().Must(BeAnExistingOdsInstanceRegistration).WithMessage("A selected instance does not exist in the database.");;
}
public RegisterOdsInstanceModelValidator(AdminAppDbContext database
, ICloudOdsAdminAppSettingsApiModeProvider apiModeProvider
, IDatabaseValidationService databaseValidationService
, IDatabaseConnectionProvider databaseConnectionProvider
, bool validationMessageWithDetails = false)
{
_database = database;
_databaseValidationService = databaseValidationService;
_databaseConnectionProvider = databaseConnectionProvider;
var requiredNumericSuffixMessage = "'ODS Instance District / EdOrg Id' must not be empty.";
var inRangeMessage = "'ODS Instance District / EdOrg Id' must be a valid positive integer.";
var maxValue = int.MaxValue;
var minValue = 1;
var beUniqueValidationMsg = "Education Organization / District Id";
_mode = apiModeProvider.GetApiMode();
if (_mode == ApiMode.YearSpecific)
{
requiredNumericSuffixMessage = "'ODS Instance School Year' must not be empty.";
maxValue = 2099;
inRangeMessage = "'ODS Instance School Year' must be between 1900 and 2099.";
beUniqueValidationMsg = "school year";
minValue = 1900;
}
RuleFor(m => m.NumericSuffix).NotEmpty().WithMessage(requiredNumericSuffixMessage);
RuleFor(m => m.NumericSuffix)
.Must(BeWithinApplicationNameMaxLength)
.When(x => x.NumericSuffix != null);
RuleFor(m => m.NumericSuffix)
.Must(x => x <= maxValue && x >= minValue)
.When(x => x.NumericSuffix != null)
.WithMessage(inRangeMessage);
RuleFor(m => m.NumericSuffix)
.Must(BeAUniqueInstanceName)
.When(x => x.NumericSuffix != null)
.WithMessage(
x => $"An instance for this {beUniqueValidationMsg}{(validationMessageWithDetails ? $"({x.NumericSuffix})":"")} already exists.");
RuleFor(m => m.NumericSuffix)
.Must(BeValidOdsInstanceDatabase)
.When(x => x.NumericSuffix != null)
.WithMessage(
x => $"Could not connect to an ODS instance database for this {beUniqueValidationMsg}{(validationMessageWithDetails ? $"({x.NumericSuffix})":"")}.");
RuleFor(m => m.Description).NotEmpty();
RuleFor(m => m.Description)
.Must(BeAUniqueInstanceDescription)
.When(x => x.Description != null)
.WithMessage(
x => $"An instance with this description{(validationMessageWithDetails ? $"({beUniqueValidationMsg}: {x.NumericSuffix}, Description: {x.Description})":"")} already exists.");
}
public DeregisterOdsInstanceModelValidator(AdminAppDbContext database)
{
_database = database;
RuleFor(m => m.OdsInstanceId)
.NotEmpty()
.Must(BeAnExistingOdsInstance).WithMessage("The instance you are trying to deregister does not exist in the database.");
RuleFor(m => m.Name).NotEmpty();
RuleFor(m => m.Description).NotEmpty();
}
private static void AddSecretConfiguration(string jsonConfiguration, int odsInstanceRegistrationId)
{
using (var database = new AdminAppDbContext())
{
database.SecretConfigurations.Add(new SecretConfiguration {
EncryptedData = jsonConfiguration, OdsInstanceRegistrationId = odsInstanceRegistrationId
});
database.SaveChanges();
}
}
private static void EnsureZeroSqlConfigurations()
{
using (var database = new AdminAppDbContext())
{
foreach (var entity in database.AzureSqlConfigurations)
{
database.AzureSqlConfigurations.Remove(entity);
}
database.SaveChanges();
}
}
public BulkRegisterOdsInstancesModelValidator(AdminAppDbContext database
, ICloudOdsAdminAppSettingsApiModeProvider apiModeProvider
, IDatabaseValidationService databaseValidationService
, IDatabaseConnectionProvider databaseConnectionProvider
, IBulkRegisterOdsInstancesFiltrationService dataFilterService)
{
var mode = apiModeProvider.GetApiMode();
RuleFor(m => m.OdsInstancesFile)
.NotEmpty();
RuleFor(m => m.OdsInstancesFile.FileName).NotNull().Must(x => x.ToLower().EndsWith(".csv"))
.WithMessage("Please select a file with .csv format.");
When(m => m.OdsInstancesFile != null, () =>
{
RuleFor(m => m).SafeCustom(HaveValidHeaders);
});
When(m => m.OdsInstancesFile != null && !ValidHeadersRuleFailed, () =>
{
RuleFor(m => m).SafeCustom(HaveUniqueRecords);
});
When(
m => m.OdsInstancesFile != null && !UniquenessRuleFailed && !ValidHeadersRuleFailed, () =>
{
RuleFor(x => x)
.SafeCustom(
(model, context) =>
{
var validator = new RegisterOdsInstanceModelValidator(
database, apiModeProvider, databaseValidationService,
databaseConnectionProvider, true);
var newOdsInstancesToRegister = dataFilterService.FilteredRecords(model.DataRecords(), mode).ToList();
model.FilteredDataRecords = newOdsInstancesToRegister;
foreach (var record in newOdsInstancesToRegister)
{
var data = (RegisterOdsInstanceModel)record;
var results = validator.Validate(data);
if (!results.IsValid)
{
foreach (var failure in results.Errors)
{
_logger.Error($"Property: {failure.PropertyName} failed validation. Error: {failure.ErrorMessage}");
}
}
context.AddFailures(results);
}
});
});
}
public static TResult Query <TResult>(Func <DbContext, TResult> query)
{
TResult result;
using (var database = new AdminAppDbContext())
{
result = query(database);
}
return(result);
}
private static void EnsureOneSqlConfiguration(string jsonConfiguration)
{
EnsureZeroSqlConfigurations();
using (var database = new AdminAppDbContext())
{
database.AzureSqlConfigurations.Add(new AzureSqlConfiguration {
Configurations = jsonConfiguration
});
database.SaveChanges();
}
}
public OdsInstanceFirstTimeSetupService(IOdsSecretConfigurationProvider odsSecretConfigurationProvider,
IFirstTimeSetupService firstTimeSetupService,
IUsersContext usersContext,
IReportViewsSetUp reportViewsSetUp,
AdminAppDbContext database)
{
_odsSecretConfigurationProvider = odsSecretConfigurationProvider;
_firstTimeSetupService = firstTimeSetupService;
_usersContext = usersContext;
_reportViewsSetUp = reportViewsSetUp;
_database = database;
}
private static bool TryQueryInstanceRegistration(out OdsInstanceRegistration instanceRegistration)
{
OdsInstanceRegistration singleInstanceLookup;
using (var dbContext = new AdminAppDbContext())
{
singleInstanceLookup = dbContext.OdsInstanceRegistrations.FirstOrDefault(x =>
x.Name.Equals(CloudOdsAdminAppSettings.Instance.OdsInstanceName,
StringComparison.InvariantCultureIgnoreCase));
}
instanceRegistration = singleInstanceLookup;
return(singleInstanceLookup != null);
}
private static OdsSecretConfigurationProvider OdsSecretConfigurationProvider(AdminAppDbContext database)
{
var appSettingsAccessor = new Mock <IOptions <AppSettings> >();
Scoped <IOptions <AppSettings> >(appSettings =>
{
appSettingsAccessor.Setup(x => x.Value).Returns(appSettings.Value);
});
return(new OdsSecretConfigurationProvider(
new DataProtectionAPIEncryptorService(
new EncryptionConfigurationProviderService(appSettingsAccessor.Object)), database));
}
private static OdsInstanceRegistration CreateOdsInstanceRegistration(string instanceName)
{
OdsInstanceRegistration createdOdsInstanceRegistration;
using (var database = new AdminAppDbContext())
{
database.OdsInstanceRegistrations.Add(new OdsInstanceRegistration {
Name = instanceName
});
database.SaveChanges();
createdOdsInstanceRegistration = database.OdsInstanceRegistrations.FirstOrDefault(x => x.Name == instanceName);
}
return(createdOdsInstanceRegistration);
}
private async Task <OdsSqlConfiguration> ReadSqlConfigurations()
{
using (var database = new AdminAppDbContext())
{
var rawValue = (await database.AzureSqlConfigurations.SingleOrDefaultAsync())?.Configurations;
if (rawValue == null)
{
return(null);
}
return(Json.Decode <OdsSqlConfiguration>(
_stringEncryptorService.TryDecrypt(rawValue, out var unencryptedValue)
? unencryptedValue
: rawValue));
}
}
private async Task <OdsSecretConfiguration> ReadSecretConfigurations(int?instanceRegistrationId)
{
using (var database = new AdminAppDbContext())
{
var rawValue = (await database.SecretConfigurations.SingleOrDefaultAsync(x =>
x.OdsInstanceRegistrationId == instanceRegistrationId))?.EncryptedData;
if (rawValue == null)
{
return(null);
}
return(Json.Decode <OdsSecretConfiguration>(
_stringEncryptorService.TryDecrypt(rawValue, out var unencryptedValue)
? unencryptedValue
: rawValue));
}
}
public ProductRegistration(
IOptions <AppSettings> appSettingsAccessor,
AdminAppDbContext database,
IHttpContextAccessor httpContextAccessor,
ApplicationConfigurationService applicationConfigurationService,
IGetOdsInstanceRegistrationsQuery getOdsInstanceRegistrationsQuery,
IInferOdsApiVersion inferOdsApiVersion)
{
_database = database;
_httpContextAccessor = httpContextAccessor;
_applicationConfigurationService = applicationConfigurationService;
_getOdsInstanceRegistrationsQuery = getOdsInstanceRegistrationsQuery;
_inferOdsApiVersion = inferOdsApiVersion;
var appSettings = appSettingsAccessor.Value;
_odsApiMode = appSettings.ApiStartupType;
_productRegistrationUrl = appSettings.ProductRegistrationUrl;
}
public Telemetry(IOptions <AppSettings> appSettingsAccessor, AdminAppUserContext userContext, AdminAppDbContext database, IHttpContextAccessor httpContextAccessor,
IInferOdsApiVersion inferOdsApiVersion)
{
_userContext = userContext;
_database = database;
_httpContextAccessor = httpContextAccessor;
_inferOdsApiVersion = inferOdsApiVersion;
var appSettings = appSettingsAccessor.Value;
_measurementId = appSettings.GoogleAnalyticsMeasurementId;
_informationalVersion = Version.InformationalVersion;
_environment = new SimpleTrackerEnvironment(
OSVersion.Platform.ToString(),
OSVersion.Version.ToString(),
OSVersion.VersionString
);
}
private static bool TryQueryInstanceRegistration(string userId, string unsafeInstanceId, out OdsInstanceRegistration instanceRegistration)
{
if (int.TryParse(unsafeInstanceId, out var safeInstanceId))
{
var isAuthorized = IsUserAuthorizedForInstance(safeInstanceId, userId);
OdsInstanceRegistration instanceLookup;
using (var dbContext = new AdminAppDbContext())
{
instanceLookup = dbContext.OdsInstanceRegistrations.Find(safeInstanceId);
}
if (isAuthorized && instanceLookup != null)
{
instanceRegistration = instanceLookup;
return(true);
}
}
instanceRegistration = null;
return(false);
}
public BulkRegisterOdsInstancesModelValidator(AdminAppDbContext database
, ICloudOdsAdminAppSettingsApiModeProvider apiModeProvider
, IDatabaseValidationService databaseValidationService
, IDatabaseConnectionProvider databaseConnectionProvider)
{
RuleFor(m => m.OdsInstancesFile)
.NotEmpty();
RuleFor(m => m.OdsInstancesFile)
.Must(HaveUniqueRecords)
.When(m => m.OdsInstancesFile != null);
When(
m => m.OdsInstancesFile != null && !UniquenessRuleFailed, () =>
{
RuleFor(x => x.OdsInstancesFile)
.SafeCustom(
(model, context) =>
{
var validator = new RegisterOdsInstanceModelValidator(
database, apiModeProvider, databaseValidationService,
databaseConnectionProvider, true);
foreach (var record in model.DataRecords())
{
var results = validator.Validate(record);
if (!results.IsValid)
{
foreach (var failure in results.Errors)
{
_logger.Error($"Property: {failure.PropertyName} failed validation. Error: {failure.ErrorMessage}");
}
}
context.AddFailures(results);
}
});
});
}
private async Task WriteSqlConfiguration(OdsSqlConfiguration configuration)
{
var stringValue = Json.Encode(configuration);
var encryptedValue = _stringEncryptorService.Encrypt(stringValue);
using (var database = new AdminAppDbContext())
{
var sqlConfiguration = await database.AzureSqlConfigurations.SingleOrDefaultAsync();
if (sqlConfiguration == null)
{
database.AzureSqlConfigurations.Add(new AzureSqlConfiguration
{
Configurations = encryptedValue
});
}
else
{
sqlConfiguration.Configurations = encryptedValue;
}
await database.SaveChangesAsync();
}
}
public OdsSecretConfigurationProvider(IStringEncryptorService stringEncryptorService, AdminAppDbContext database)
{
_stringEncryptorService = stringEncryptorService;
_database = database;
}
public GetOdsInstanceRegistrationsByUserIdQuery(AdminAppDbContext database, AdminAppIdentityDbContext identity)
{
_database = database;
_identity = identity;
}
private OdsInstanceFirstTimeSetupService GetOdsInstanceFirstTimeSetupService(string encryptedSecretConfigValue,
string instanceName, AdminAppDbContext database, ApiMode apiMode)
{
var appSettings = new Mock <IOptions <AppSettings> >();
appSettings.Setup(x => x.Value).Returns(new AppSettings());
var options = appSettings.Object;
var mockStringEncryptorService = new Mock <IStringEncryptorService>();
mockStringEncryptorService.Setup(x => x.Encrypt(It.IsAny <string>())).Returns(encryptedSecretConfigValue);
var odsSecretConfigurationProvider = new OdsSecretConfigurationProvider(mockStringEncryptorService.Object, database);
var mockFirstTimeSetupService = new Mock <IFirstTimeSetupService>();
var mockReportViewsSetUp = new Mock <IReportViewsSetUp>();
var mockUsersContext = new Mock <IUsersContext>();
mockFirstTimeSetupService.Setup(x => x.CreateAdminAppInAdminDatabase(It.IsAny <string>(), instanceName,
It.IsAny <string>(), apiMode)).ReturnsAsync(new ApplicationCreateResult());
var odsInstanceFirstTimeSetupService = new OdsInstanceFirstTimeSetupService(odsSecretConfigurationProvider,
mockFirstTimeSetupService.Object, mockUsersContext.Object, mockReportViewsSetUp.Object, database, options);
return(odsInstanceFirstTimeSetupService);
}
public BulkRegisterOdsInstancesFiltrationService(AdminAppDbContext database,
IDatabaseConnectionProvider databaseConnectionProvider)
{
_database = database;
_databaseConnectionProvider = databaseConnectionProvider;
}
public BulkRegisterOdsInstancesFiltrationService(AdminAppDbContext database
, IInferInstanceService inferInstanceService)
{
_database = database;
_inferInstanceService = inferInstanceService;
}
