public VirtualMachineCreateService(
IConfiguration config,
SepesDbContext db,
ILogger <VirtualMachineCreateService> logger,
IMapper mapper,
IUserService userService,
ISandboxModelService sandboxModelService,
ICloudResourceCreateService cloudResourceCreateService,
ICloudResourceReadService cloudResourceReadService,
ICloudResourceUpdateService cloudResourceUpdateService,
ICloudResourceDeleteService cloudResourceDeleteService,
IProvisioningQueueService provisioningQueueService,
IAzureKeyVaultSecretService azureKeyVaultSecretService,
IVirtualMachineOperatingSystemService virtualMachineOperatingSystemService
)
: base(config, db, logger, mapper, userService, cloudResourceReadService)
{
_sandboxModelService = sandboxModelService;
_cloudResourceCreateService = cloudResourceCreateService;
_cloudResourceUpdateService = cloudResourceUpdateService;
_cloudResourceDeleteService = cloudResourceDeleteService;
_provisioningQueueService = provisioningQueueService;
_azureKeyVaultSecretService = azureKeyVaultSecretService;
_virtualMachineOperatingSystemService = virtualMachineOperatingSystemService;
}
public static IQueryable <SandboxDataset> SandboxDatasetForPhaseShift(SepesDbContext db)
{
return(db.SandboxDatasets
.Include(sds => sds.Dataset)
.ThenInclude(ds => ds.Resources)
.ThenInclude(ds => ds.Operations));
}
public static async Task <int> GetCreateOperationIdForBastion(SepesDbContext db, int sandboxId)
{
var bastionResourceForSandbox = await WithBasicIncludesQueryable(db).SingleOrDefaultAsync(r => r.SandboxId == sandboxId && r.ResourceType == AzureResourceType.Bastion);
if (bastionResourceForSandbox == null)
{
throw new Exception($"Could not locate Bastion resource entry");
}
if (bastionResourceForSandbox.Deleted || bastionResourceForSandbox.Operations.FirstOrDefault(o => o.OperationType == CloudResourceOperationType.DELETE) != null)
{
throw new Exception($"Bastion resource entry ({bastionResourceForSandbox.Id}) is marked for deletion");
}
var latestOperationEntry = bastionResourceForSandbox.Operations.OrderByDescending(o => o.Created).FirstOrDefault();
if (latestOperationEntry.OperationType == CloudResourceOperationType.UPDATE)
{
//TODO: Add additional checks?
return(latestOperationEntry.Id);
}
else if (latestOperationEntry.OperationType == CloudResourceOperationType.CREATE)
{
return(latestOperationEntry.Id);
}
throw new Exception($"Could not locate suitable Bastion resource operation entry");
}
void DoMigration(bool enableSensitiveDataLogging)
{
var disableMigrations = _configuration[ConfigConstants.DISABLE_MIGRATIONS];
if (!String.IsNullOrWhiteSpace(disableMigrations) && disableMigrations.ToLower() == "true")
{
Log("Migrations are disabled and will be skipped!");
return;
}
else
{
Log("Performing database migrations");
}
string sqlConnectionStringOwner = GetConnectionString(ConfigConstants.DB_OWNER_CONNECTION_STRING, enableSensitiveDataLogging); // _configuration[ConfigConstants.DB_OWNER_CONNECTION_STRING];
var createDbOptions = new DbContextOptionsBuilder <SepesDbContext>();
createDbOptions.UseSqlServer(sqlConnectionStringOwner);
createDbOptions.EnableSensitiveDataLogging(enableSensitiveDataLogging);
using (var ctx = new SepesDbContext(createDbOptions.Options))
{
ctx.Database.SetCommandTimeout(300);
ctx.Database.Migrate();
}
Log("Do migration done");
}
public static IQueryable <Study> StudySandboxCreationQueryable(SepesDbContext db)
{
return(ActiveStudiesBaseQueryable(db)
.Include(s => s.StudyParticipants)
.ThenInclude(sp => sp.User)
.Include(s => s.Sandboxes));
}
public LookupService(SepesDbContext db, IMapper mapper, IUserService userService, IStudyEfModelService studyModelService)
{
_mapper = mapper;
_userService = userService;
_db = db;
_studyModelService = studyModelService;
}
public StudyServiceBase(SepesDbContext db, IMapper mapper, ILogger logger, IUserService userService, IStudyEfModelService studyModelService, IStudyLogoReadService studyLogoReadService)
: base(db, mapper, userService)
{
_logger = logger;
_studyModelService = studyModelService;
_studyLogoReadService = studyLogoReadService;
}
public StudyDatasetService(SepesDbContext db, IMapper mapper, ILogger <StudyDatasetService> logger, IUserService userService,
IStudyPermissionService studyPermissionService,
IStudyEfModelService studyModelService, IStudySpecificDatasetModelService studySpecificDatasetModelService)
: base(db, mapper, logger, userService, studyPermissionService)
{
_studyModelService = studyModelService;
_studySpecificDatasetModelService = studySpecificDatasetModelService;
}
static IQueryable <CloudResource> WithBasicIncludesQueryable(SepesDbContext db)
{
return(db.CloudResources
.Include(r => r.Operations)
.Include(sr => sr.Sandbox)
.ThenInclude(sb => sb.Study)
.ThenInclude(s => s.StudyParticipants));
}
public static IQueryable <CloudResource> GetResource(SepesDbContext db, int resourceId)
{
var resourceQuerable =
WithBasicIncludesQueryable(db)
.Where(r => r.Id == resourceId &&
(!r.Deleted || (r.Deleted && !r.Operations.Where(o => o.OperationType == CloudResourceOperationType.DELETE && o.Status == CloudResourceOperationState.DONE_SUCCESSFUL).Any())));
return(resourceQuerable);
}
public static IQueryable <Study> ActiveStudiesIncludingHiddenQueryable(SepesDbContext db, int userId)
{
//TOD: Review access check. As of now, if the user has ANY role associated with a study, he can view it
return(StudyBaseQueries.ActiveStudiesBaseQueryable(db)
.Include(s => s.StudyParticipants)
.ThenInclude(sp => sp.User)
.Where(s =>
(!s.Restricted || s.StudyParticipants.Where(sp => sp.UserId == userId).Any())));
}
public VirtualMachineSizeService(
SepesDbContext db,
IMapper mapper,
ISandboxModelService sandboxModelService)
{
_db = db;
_mapper = mapper;
_sandboxModelService = sandboxModelService;
}
public static IQueryable <Study> StudyDatasetsQueryable(SepesDbContext db)
{
return(ActiveStudiesBaseQueryable(db)
.Include(s => s.StudyParticipants)
.ThenInclude(sp => sp.User)
.Include(s => s.StudyDatasets)
.ThenInclude(sd => sd.Dataset)
.ThenInclude(sd => sd.Resources));
}
public static IQueryable <Sandbox> AllSandboxesBaseQueryable(SepesDbContext db)
{
return(db.Sandboxes.Include(s => s.Study)
.ThenInclude(s => s.StudyParticipants)
.Include(sb => sb.SandboxDatasets)
.ThenInclude(sd => sd.Dataset)
.Include(sb => sb.Resources)
.ThenInclude(r => r.Operations)
.Include(sb => sb.PhaseHistory));
}
public static IQueryable <Sandbox> ForResourceCreation(SepesDbContext db)
{
return(ActiveSandboxesBaseQueryable(db)
.Include(s => s.Study)
.ThenInclude(s => s.StudyParticipants)
.ThenInclude(sp => sp.User)
.Include(sb => sb.Resources)
.ThenInclude(r => r.Operations)
.Include(sb => sb.PhaseHistory));
}
public static IQueryable <Sandbox> ActiveSandboxesWithIncludesQueryable(SepesDbContext db)
{
return(ActiveSandboxesMinimalIncludesQueryable(db)
.Include(sb => sb.SandboxDatasets)
.ThenInclude(sd => sd.Dataset)
.ThenInclude(ds => ds.Resources)
.Include(sb => sb.Resources)
.ThenInclude(r => r.Operations)
.Include(sb => sb.PhaseHistory));
}
protected User DecorateWithUser(SepesDbContext db, int userId)
{
var user = new User()
{
Id = userId, UserName = $"Test user with Id {userId}"
};
db.Users.Add(user);
return(user);
}
public static IQueryable <Sandbox> SandboxForPhaseShift(SepesDbContext db)
{
return(ActiveSandboxesMinimalIncludesQueryable(db)
.Include(sb => sb.Resources)
.ThenInclude(r => r.Operations)
.Include(sb => sb.PhaseHistory)
.Include(sb => sb.SandboxDatasets));
//.ThenInclude(sds => sds.Dataset)
// .ThenInclude(ds => ds.Resources)
// .ThenInclude(ds => ds.Operations);
}
public VirtualMachineDiskSizeImportService(
ILogger <VirtualMachineDiskSizeImportService> logger,
SepesDbContext db,
IUserService userService,
IAzureDiskPriceService azureDiskPriceService)
{
_logger = logger;
_db = db;
_userService = userService;
_azureDiskPriceService = azureDiskPriceService;
}
public StudyDeleteService(SepesDbContext db, IMapper mapper, ILogger <StudyDeleteService> logger, IUserService userService, IStudyEfModelService studyModelService,
IStudyLogoReadService studyLogoReadService,
IStudyLogoDeleteService studyLogoDeleteService,
IStudySpecificDatasetService studySpecificDatasetService,
ICloudResourceReadService cloudResourceReadService)
: base(db, mapper, logger, userService, studyModelService, studyLogoReadService)
{
_studyLogoDeleteService = studyLogoDeleteService;
_studySpecificDatasetService = studySpecificDatasetService;
_cloudResourceReadService = cloudResourceReadService;
}
public static async Task <CloudResource> GetSingleResourceEntry(SepesDbContext db, int sandboxId, string resourceType)
{
var resourceEntry = await WithBasicIncludesQueryable(db).SingleOrDefaultAsync(r => r.SandboxId == sandboxId && r.ResourceType == resourceType && r.SandboxControlled);
if (resourceEntry == null)
{
throw new Exception($"Could not locate Sandbox Resource database entry for type {resourceType}");
}
return(resourceEntry);
}
public static IQueryable <Sandbox> SandboxForDatasetOperations(SepesDbContext db, bool includePhase = false)
{
return(ActiveSandboxesBaseQueryable(db)
.Include(sb => sb.Study)
.ThenInclude(s => s.StudyParticipants)
.Include(sb => sb.Study)
.ThenInclude(s => s.StudyDatasets)
.ThenInclude(sd => sd.Dataset)
.ThenInclude(sd => sd.SandboxDatasets)
.If(includePhase, x => x.Include(sb => sb.PhaseHistory)));
}
public static void AddWithOpen(SepesDbContext db, int sandboxId, string sandboxName)
{
var phaseHistory = new List <SandboxPhaseHistory>()
{
new SandboxPhaseHistory()
{
Counter = 0, Phase = SandboxPhase.Open
}
};
AddWithTwoDatasets(db, sandboxId, sandboxName, phaseHistory);
}
public SandboxResourceDeleteService(SepesDbContext db, ILogger <SandboxResourceDeleteService> logger,
ISandboxModelService sandboxModelService,
ICloudResourceDeleteService cloudResourceDeleteService, ICloudResourceOperationCreateService cloudResourceOperationCreateService,
IProvisioningQueueService provisioningQueueService)
{
_logger = logger;
_db = db;
_sandboxModelService = sandboxModelService;
_cloudResourceDeleteService = cloudResourceDeleteService;
_cloudResourceOperationCreateService = cloudResourceOperationCreateService;
_provisioningQueueService = provisioningQueueService;
}
public static IQueryable <Study> StudyDetailsQueryable(SepesDbContext db)
{
return(ActiveStudiesBaseQueryable(db)
.Include(s => s.StudyParticipants)
.ThenInclude(sp => sp.User)
.Include(s => s.Sandboxes)
.Include(s => s.StudyDatasets)
.ThenInclude(sd => sd.Dataset)
.ThenInclude(sd => sd.SandboxDatasets)
.ThenInclude(sd => sd.Sandbox)
.AsNoTracking());
}
public static void Add(SepesDbContext db, string studyName, string vendor, string wbs, int ownerId)
{
var newStudy = StudyFactory.Create(studyName, vendor, wbs, new List <StudyParticipant>()
{
new StudyParticipant()
{
UserId = ownerId, RoleName = StudyRoles.StudyOwner
}
});
db.Studies.Add(newStudy);
}
public VirtualMachineSizeImportService(
ILogger <VirtualMachineSizeImportService> logger,
SepesDbContext db,
IUserService userService,
IAzureResourceSkuService azureResourceSkuService,
IAzureCostManagementService azureCostManagementService)
{
_logger = logger;
_db = db;
_userService = userService;
_azureResourceSkuService = azureResourceSkuService;
_azureCostManagementService = azureCostManagementService;
}
public DatasetFileService(SepesDbContext db, IMapper mapper, ILogger <DatasetFileService> logger, IUserService userService,
IStudyPermissionService studyPermissionService,
IStudySpecificDatasetModelService studySpecificDatasetModelService,
IAzureBlobStorageService storageService,
IDatasetCloudResourceService datasetCloudResourceService,
IAzureBlobStorageUriBuilderService azureStorageAccountTokenService)
: base(db, mapper, logger, userService, studyPermissionService)
{
_storageService = storageService;
_studySpecificDatasetModelService = studySpecificDatasetModelService;
_datasetCloudResourceService = datasetCloudResourceService;
_azureStorageAccountTokenService = azureStorageAccountTokenService;
}
public StudyParticipantRemoveService(SepesDbContext db,
IMapper mapper,
ILogger <StudyParticipantRemoveService> logger,
IUserService userService,
IStudyEfModelService studyModelService,
IProvisioningQueueService provisioningQueueService,
ICloudResourceReadService cloudResourceReadService,
ICloudResourceOperationCreateService cloudResourceOperationCreateService,
ICloudResourceOperationUpdateService cloudResourceOperationUpdateService
)
: base(db, mapper, logger, userService, studyModelService, provisioningQueueService, cloudResourceReadService, cloudResourceOperationCreateService, cloudResourceOperationUpdateService)
{
}
public static IQueryable <CloudResource> ResourcesByTypeQueryable(SepesDbContext db, int sandboxId, string resourceType, bool includeDeletedIfOperationNotFinished = false)
{
var resourceQuerable =
WithBasicIncludesQueryable(db)
.Where(r => r.SandboxId == sandboxId &&
r.ResourceType == resourceType &&
(!r.Deleted ||
(r.Deleted && includeDeletedIfOperationNotFinished && !r.Operations.Where(o => o.OperationType == CloudResourceOperationType.DELETE && o.Status == CloudResourceOperationState.DONE_SUCCESSFUL).Any())));
return(resourceQuerable);
}
