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); }