target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void testDeleteNotebook() { Workspace workspace = createWorkspace(); workspace = workspacesController.createWorkspace(workspace).getBody(); String nb1 = NotebooksService.withNotebookExtension("notebooks/nb1"); String fullPath = BUCKET_URI + nb1; long workspaceIdInDb = 1; long userIdInDb = 1; workspacesController.deleteNotebook( workspace.getNamespace(), workspace.getId(), NotebooksService.withNotebookExtension("nb1")); verify(cloudStorageService).deleteBlob(BlobId.of(TestMockFactory.WORKSPACE_BUCKET_NAME, nb1)); verify(userRecentResourceService).deleteNotebookEntry(workspaceIdInDb, userIdInDb, fullPath); } | @Override public ResponseEntity<EmptyResponse> deleteNotebook( String workspace, String workspaceName, String notebookName) { recordOperationTime( () -> notebooksService.deleteNotebook(workspace, workspaceName, notebookName), "deleteNotebook"); return ResponseEntity.ok(new EmptyResponse()); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<EmptyResponse> deleteNotebook( String workspace, String workspaceName, String notebookName) { recordOperationTime( () -> notebooksService.deleteNotebook(workspace, workspaceName, notebookName), "deleteNotebook"); return ResponseEntity.ok(new EmptyResponse()); } } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<EmptyResponse> deleteNotebook( String workspace, String workspaceName, String notebookName) { recordOperationTime( () -> notebooksService.deleteNotebook(workspace, workspaceName, notebookName), "deleteNotebook"); return ResponseEntity.ok(new EmptyResponse()); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<EmptyResponse> deleteNotebook( String workspace, String workspaceName, String notebookName) { recordOperationTime( () -> notebooksService.deleteNotebook(workspace, workspaceName, notebookName), "deleteNotebook"); return ResponseEntity.ok(new EmptyResponse()); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<EmptyResponse> deleteNotebook( String workspace, String workspaceName, String notebookName) { recordOperationTime( () -> notebooksService.deleteNotebook(workspace, workspaceName, notebookName), "deleteNotebook"); return ResponseEntity.ok(new EmptyResponse()); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } |
@Test public void testGetPublishedWorkspaces() { stubFcGetGroup(); stubFcUpdateWorkspaceACL(); Workspace workspace = createWorkspace(); workspace = workspacesController.createWorkspace(workspace).getBody(); workspacesController.publishWorkspace(workspace.getNamespace(), workspace.getId()); FirecloudWorkspaceResponse fcResponse = new FirecloudWorkspaceResponse(); fcResponse.setWorkspace( testMockFactory.createFirecloudWorkspace( workspace.getNamespace(), workspace.getName(), null)); fcResponse.setAccessLevel(WorkspaceAccessLevel.OWNER.toString()); doReturn(Collections.singletonList(fcResponse)).when(fireCloudService).getWorkspaces(); assertThat(workspacesController.getPublishedWorkspaces().getBody().getItems().size()) .isEqualTo(1); } | @Override public ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces() { WorkspaceResponseListResponse response = new WorkspaceResponseListResponse(); response.setItems(workspaceService.getPublishedWorkspaces()); return ResponseEntity.ok(response); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces() { WorkspaceResponseListResponse response = new WorkspaceResponseListResponse(); response.setItems(workspaceService.getPublishedWorkspaces()); return ResponseEntity.ok(response); } } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces() { WorkspaceResponseListResponse response = new WorkspaceResponseListResponse(); response.setItems(workspaceService.getPublishedWorkspaces()); return ResponseEntity.ok(response); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces() { WorkspaceResponseListResponse response = new WorkspaceResponseListResponse(); response.setItems(workspaceService.getPublishedWorkspaces()); return ResponseEntity.ok(response); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces() { WorkspaceResponseListResponse response = new WorkspaceResponseListResponse(); response.setItems(workspaceService.getPublishedWorkspaces()); return ResponseEntity.ok(response); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } |
@Test public void notebookLockingEmailHashTest() { final String[][] knownTestData = { { "fc-bucket-id-1", "user@aou", "dc5acd54f734a2e2350f2adcb0a25a4d1978b45013b76d6bc0a2d37d035292fe" }, { "fc-bucket-id-1", "another-user@aou", "bc90f9f740702e5e0408f2ea13fed9457a7ee9c01117820f5c541067064468c3" }, { "fc-bucket-id-2", "user@aou", "a759e5aef091fd22bbf40bf8ee7cfde4988c668541c18633bd79ab84b274d622" }, { "fc-5ac6bde3-f225-44ca-ad4d-92eed68df7db", "[email protected]", "060c0b2ef2385804b7b69a4b4477dd9661be35db270c940525c2282d081aef56" } }; for (final String[] test : knownTestData) { final String bucket = test[0]; final String email = test[1]; final String hash = test[2]; assertThat(WorkspacesController.notebookLockingEmailHash(bucket, email)).isEqualTo(hash); } } | @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } |
@Test public void testNotebookLockingMetadata() { final String lastLockedUser = LOGGED_IN_USER_EMAIL; final Long lockExpirationTime = Instant.now().plus(Duration.ofMinutes(1)).toEpochMilli(); final Map<String, String> gcsMetadata = new ImmutableMap.Builder<String, String>() .put(LOCK_EXPIRE_TIME_KEY, lockExpirationTime.toString()) .put( LAST_LOCKING_USER_KEY, WorkspacesController.notebookLockingEmailHash( TestMockFactory.WORKSPACE_BUCKET_NAME, lastLockedUser)) .put("extraMetadata", "is not a problem") .build(); final NotebookLockingMetadataResponse expectedResponse = new NotebookLockingMetadataResponse() .lockExpirationTime(lockExpirationTime) .lastLockedBy(lastLockedUser); assertNotebookLockingMetadata(gcsMetadata, expectedResponse, fcWorkspaceAcl); } | @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } |
@Test public void testNotebookLockingMetadataKnownUser() { final String readerOnMyWorkspace = "[email protected]"; FirecloudWorkspaceACL workspaceACL = createWorkspaceACL( new JSONObject() .put( currentUser.getUsername(), new JSONObject() .put("accessLevel", "OWNER") .put("canCompute", true) .put("canShare", true)) .put( readerOnMyWorkspace, new JSONObject() .put("accessLevel", "READER") .put("canCompute", true) .put("canShare", true))); final String lastLockedUser = readerOnMyWorkspace; final Long lockExpirationTime = Instant.now().plus(Duration.ofMinutes(1)).toEpochMilli(); final Map<String, String> gcsMetadata = new ImmutableMap.Builder<String, String>() .put(LOCK_EXPIRE_TIME_KEY, lockExpirationTime.toString()) .put( LAST_LOCKING_USER_KEY, WorkspacesController.notebookLockingEmailHash( TestMockFactory.WORKSPACE_BUCKET_NAME, lastLockedUser)) .put("extraMetadata", "is not a problem") .build(); final NotebookLockingMetadataResponse expectedResponse = new NotebookLockingMetadataResponse() .lockExpirationTime(lockExpirationTime) .lastLockedBy(readerOnMyWorkspace); assertNotebookLockingMetadata(gcsMetadata, expectedResponse, workspaceACL); } | @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } |
@Test public void testNotebookLockingMetadataUnknownUser() { final String lastLockedUser = "[email protected]"; final Long lockExpirationTime = Instant.now().plus(Duration.ofMinutes(1)).toEpochMilli(); final Map<String, String> gcsMetadata = new ImmutableMap.Builder<String, String>() .put(LOCK_EXPIRE_TIME_KEY, lockExpirationTime.toString()) .put( LAST_LOCKING_USER_KEY, WorkspacesController.notebookLockingEmailHash( TestMockFactory.WORKSPACE_BUCKET_NAME, lastLockedUser)) .put("extraMetadata", "is not a problem") .build(); final NotebookLockingMetadataResponse expectedResponse = new NotebookLockingMetadataResponse() .lockExpirationTime(lockExpirationTime) .lastLockedBy("UNKNOWN"); assertNotebookLockingMetadata(gcsMetadata, expectedResponse, fcWorkspaceAcl); } | @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } | WorkspacesController implements WorkspacesApiDelegate { @VisibleForTesting static String notebookLockingEmailHash(String bucket, String email) { String toHash = String.format("%s:%s", bucket, email); try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] hash = sha256.digest(toHash.getBytes(StandardCharsets.UTF_8)); return BaseEncoding.base16().lowerCase().encode(hash); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } |
@Test public void testGetBillingUsage() { Double cost = 150.50; Workspace ws = createWorkspace(); stubGetWorkspace(ws.getNamespace(), ws.getId(), ws.getCreator(), WorkspaceAccessLevel.OWNER); when(mockFreeTierBillingService.getWorkspaceFreeTierBillingUsage(any())).thenReturn(cost); WorkspaceBillingUsageResponse workspaceBillingUsageResponse = workspacesController.getBillingUsage(ws.getNamespace(), ws.getId()).getBody(); assertThat(workspaceBillingUsageResponse.getCost()).isEqualTo(cost); } | @Override public ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage( String workspaceNamespace, String workspaceId) { workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, workspaceId, WorkspaceAccessLevel.WRITER); return ResponseEntity.ok( new WorkspaceBillingUsageResponse() .cost( freeTierBillingService.getWorkspaceFreeTierBillingUsage( workspaceService.get(workspaceNamespace, workspaceId)))); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage( String workspaceNamespace, String workspaceId) { workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, workspaceId, WorkspaceAccessLevel.WRITER); return ResponseEntity.ok( new WorkspaceBillingUsageResponse() .cost( freeTierBillingService.getWorkspaceFreeTierBillingUsage( workspaceService.get(workspaceNamespace, workspaceId)))); } } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage( String workspaceNamespace, String workspaceId) { workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, workspaceId, WorkspaceAccessLevel.WRITER); return ResponseEntity.ok( new WorkspaceBillingUsageResponse() .cost( freeTierBillingService.getWorkspaceFreeTierBillingUsage( workspaceService.get(workspaceNamespace, workspaceId)))); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage( String workspaceNamespace, String workspaceId) { workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, workspaceId, WorkspaceAccessLevel.WRITER); return ResponseEntity.ok( new WorkspaceBillingUsageResponse() .cost( freeTierBillingService.getWorkspaceFreeTierBillingUsage( workspaceService.get(workspaceNamespace, workspaceId)))); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage( String workspaceNamespace, String workspaceId) { workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, workspaceId, WorkspaceAccessLevel.WRITER); return ResponseEntity.ok( new WorkspaceBillingUsageResponse() .cost( freeTierBillingService.getWorkspaceFreeTierBillingUsage( workspaceService.get(workspaceNamespace, workspaceId)))); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } |
@Test public void getUserRecentWorkspaces() { Workspace workspace = createWorkspace(); workspace = workspacesController.createWorkspace(workspace).getBody(); stubGetWorkspace( workspace.getNamespace(), workspace.getName(), LOGGED_IN_USER_EMAIL, WorkspaceAccessLevel.OWNER); DbWorkspace dbWorkspace = workspaceService.get(workspace.getNamespace(), workspace.getId()); workspaceService.updateRecentWorkspaces(dbWorkspace, currentUser.getUserId(), NOW); ResponseEntity<RecentWorkspaceResponse> recentWorkspaceResponseEntity = workspacesController.getUserRecentWorkspaces(); RecentWorkspace recentWorkspace = recentWorkspaceResponseEntity.getBody().get(0); assertThat(recentWorkspace.getWorkspace().getNamespace()) .isEqualTo(dbWorkspace.getWorkspaceNamespace()); assertThat(recentWorkspace.getWorkspace().getName()).isEqualTo(dbWorkspace.getName()); } | @Override public ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces() { List<DbUserRecentWorkspace> userRecentWorkspaces = workspaceService.getRecentWorkspaces(); List<Long> workspaceIds = userRecentWorkspaces.stream() .map(DbUserRecentWorkspace::getWorkspaceId) .collect(Collectors.toList()); List<DbWorkspace> dbWorkspaces = workspaceService.getDao().findAllByWorkspaceIdIn(workspaceIds); Map<Long, DbWorkspace> dbWorkspacesById = dbWorkspaces.stream() .collect(Collectors.toMap(DbWorkspace::getWorkspaceId, Function.identity())); final Map<Long, WorkspaceAccessLevel> workspaceAccessLevelsById; try { workspaceAccessLevelsById = dbWorkspaces.stream() .collect( Collectors.toMap( DbWorkspace::getWorkspaceId, dbWorkspace -> workspaceService.getWorkspaceAccessLevel( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()))); } catch (IllegalArgumentException e) { throw new ServerErrorException(e); } RecentWorkspaceResponse recentWorkspaceResponse = new RecentWorkspaceResponse(); List<RecentWorkspace> recentWorkspaces = userRecentWorkspaces.stream() .map( userRecentWorkspace -> workspaceMapper.toApiRecentWorkspace( dbWorkspacesById.get(userRecentWorkspace.getWorkspaceId()), workspaceAccessLevelsById.get(userRecentWorkspace.getWorkspaceId()))) .collect(Collectors.toList()); recentWorkspaceResponse.addAll(recentWorkspaces); return ResponseEntity.ok(recentWorkspaceResponse); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces() { List<DbUserRecentWorkspace> userRecentWorkspaces = workspaceService.getRecentWorkspaces(); List<Long> workspaceIds = userRecentWorkspaces.stream() .map(DbUserRecentWorkspace::getWorkspaceId) .collect(Collectors.toList()); List<DbWorkspace> dbWorkspaces = workspaceService.getDao().findAllByWorkspaceIdIn(workspaceIds); Map<Long, DbWorkspace> dbWorkspacesById = dbWorkspaces.stream() .collect(Collectors.toMap(DbWorkspace::getWorkspaceId, Function.identity())); final Map<Long, WorkspaceAccessLevel> workspaceAccessLevelsById; try { workspaceAccessLevelsById = dbWorkspaces.stream() .collect( Collectors.toMap( DbWorkspace::getWorkspaceId, dbWorkspace -> workspaceService.getWorkspaceAccessLevel( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()))); } catch (IllegalArgumentException e) { throw new ServerErrorException(e); } RecentWorkspaceResponse recentWorkspaceResponse = new RecentWorkspaceResponse(); List<RecentWorkspace> recentWorkspaces = userRecentWorkspaces.stream() .map( userRecentWorkspace -> workspaceMapper.toApiRecentWorkspace( dbWorkspacesById.get(userRecentWorkspace.getWorkspaceId()), workspaceAccessLevelsById.get(userRecentWorkspace.getWorkspaceId()))) .collect(Collectors.toList()); recentWorkspaceResponse.addAll(recentWorkspaces); return ResponseEntity.ok(recentWorkspaceResponse); } } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces() { List<DbUserRecentWorkspace> userRecentWorkspaces = workspaceService.getRecentWorkspaces(); List<Long> workspaceIds = userRecentWorkspaces.stream() .map(DbUserRecentWorkspace::getWorkspaceId) .collect(Collectors.toList()); List<DbWorkspace> dbWorkspaces = workspaceService.getDao().findAllByWorkspaceIdIn(workspaceIds); Map<Long, DbWorkspace> dbWorkspacesById = dbWorkspaces.stream() .collect(Collectors.toMap(DbWorkspace::getWorkspaceId, Function.identity())); final Map<Long, WorkspaceAccessLevel> workspaceAccessLevelsById; try { workspaceAccessLevelsById = dbWorkspaces.stream() .collect( Collectors.toMap( DbWorkspace::getWorkspaceId, dbWorkspace -> workspaceService.getWorkspaceAccessLevel( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()))); } catch (IllegalArgumentException e) { throw new ServerErrorException(e); } RecentWorkspaceResponse recentWorkspaceResponse = new RecentWorkspaceResponse(); List<RecentWorkspace> recentWorkspaces = userRecentWorkspaces.stream() .map( userRecentWorkspace -> workspaceMapper.toApiRecentWorkspace( dbWorkspacesById.get(userRecentWorkspace.getWorkspaceId()), workspaceAccessLevelsById.get(userRecentWorkspace.getWorkspaceId()))) .collect(Collectors.toList()); recentWorkspaceResponse.addAll(recentWorkspaces); return ResponseEntity.ok(recentWorkspaceResponse); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces() { List<DbUserRecentWorkspace> userRecentWorkspaces = workspaceService.getRecentWorkspaces(); List<Long> workspaceIds = userRecentWorkspaces.stream() .map(DbUserRecentWorkspace::getWorkspaceId) .collect(Collectors.toList()); List<DbWorkspace> dbWorkspaces = workspaceService.getDao().findAllByWorkspaceIdIn(workspaceIds); Map<Long, DbWorkspace> dbWorkspacesById = dbWorkspaces.stream() .collect(Collectors.toMap(DbWorkspace::getWorkspaceId, Function.identity())); final Map<Long, WorkspaceAccessLevel> workspaceAccessLevelsById; try { workspaceAccessLevelsById = dbWorkspaces.stream() .collect( Collectors.toMap( DbWorkspace::getWorkspaceId, dbWorkspace -> workspaceService.getWorkspaceAccessLevel( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()))); } catch (IllegalArgumentException e) { throw new ServerErrorException(e); } RecentWorkspaceResponse recentWorkspaceResponse = new RecentWorkspaceResponse(); List<RecentWorkspace> recentWorkspaces = userRecentWorkspaces.stream() .map( userRecentWorkspace -> workspaceMapper.toApiRecentWorkspace( dbWorkspacesById.get(userRecentWorkspace.getWorkspaceId()), workspaceAccessLevelsById.get(userRecentWorkspace.getWorkspaceId()))) .collect(Collectors.toList()); recentWorkspaceResponse.addAll(recentWorkspaces); return ResponseEntity.ok(recentWorkspaceResponse); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces() { List<DbUserRecentWorkspace> userRecentWorkspaces = workspaceService.getRecentWorkspaces(); List<Long> workspaceIds = userRecentWorkspaces.stream() .map(DbUserRecentWorkspace::getWorkspaceId) .collect(Collectors.toList()); List<DbWorkspace> dbWorkspaces = workspaceService.getDao().findAllByWorkspaceIdIn(workspaceIds); Map<Long, DbWorkspace> dbWorkspacesById = dbWorkspaces.stream() .collect(Collectors.toMap(DbWorkspace::getWorkspaceId, Function.identity())); final Map<Long, WorkspaceAccessLevel> workspaceAccessLevelsById; try { workspaceAccessLevelsById = dbWorkspaces.stream() .collect( Collectors.toMap( DbWorkspace::getWorkspaceId, dbWorkspace -> workspaceService.getWorkspaceAccessLevel( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()))); } catch (IllegalArgumentException e) { throw new ServerErrorException(e); } RecentWorkspaceResponse recentWorkspaceResponse = new RecentWorkspaceResponse(); List<RecentWorkspace> recentWorkspaces = userRecentWorkspaces.stream() .map( userRecentWorkspace -> workspaceMapper.toApiRecentWorkspace( dbWorkspacesById.get(userRecentWorkspace.getWorkspaceId()), workspaceAccessLevelsById.get(userRecentWorkspace.getWorkspaceId()))) .collect(Collectors.toList()); recentWorkspaceResponse.addAll(recentWorkspaces); return ResponseEntity.ok(recentWorkspaceResponse); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } |
@Test public void getWorkspaceResources() { CdrVersionContext.setCdrVersionNoCheckAuthDomain(cdrVersion); Workspace workspace = workspacesController.createWorkspace(createWorkspace()).getBody(); Cohort cohort = cohortsController .createCohort( workspace.getNamespace(), workspace.getId(), createDefaultCohort("cohort")) .getBody(); stubBigQueryCohortCalls(); CohortReview cohortReview = cohortReviewController .createCohortReview( workspace.getNamespace(), workspace.getId(), cohort.getId(), cdrVersion.getCdrVersionId(), new CreateReviewRequest().size(1)) .getBody(); ConceptSet conceptSet = conceptSetsController .createConceptSet( workspace.getNamespace(), workspace.getId(), new CreateConceptSetRequest() .conceptSet( new ConceptSet().name("cs1").description("d1").domain(Domain.CONDITION)) .addAddedIdsItem(CONCEPT_1.getConceptId())) .getBody(); DataSet dataSet = dataSetController .createDataSet( workspace.getNamespace(), workspace.getId(), new DataSetRequest() .prePackagedConceptSet(PrePackagedConceptSetEnum.NONE) .addConceptSetIdsItem(conceptSet.getId()) .addCohortIdsItem(cohort.getId()) .name("dataset") .domainValuePairs( ImmutableList.of( new DomainValuePair().value("VALUE").domain(Domain.CONDITION)))) .getBody(); WorkspaceResourcesRequest workspaceResourcesRequest = new WorkspaceResourcesRequest(); workspaceResourcesRequest.setTypesToFetch( ImmutableList.of( ResourceType.COHORT, ResourceType.COHORT_REVIEW, ResourceType.CONCEPT_SET, ResourceType.DATASET)); WorkspaceResourceResponse workspaceResourceResponse = workspacesController .getWorkspaceResources( workspace.getNamespace(), workspace.getId(), workspaceResourcesRequest) .getBody(); assertThat(workspaceResourceResponse.size()).isEqualTo(4); List<Cohort> cohorts = workspaceResourceResponse.stream() .map(WorkspaceResource::getCohort) .filter(Objects::nonNull) .collect(Collectors.toList()); List<CohortReview> cohortReviews = workspaceResourceResponse.stream() .map(WorkspaceResource::getCohortReview) .filter(Objects::nonNull) .collect(Collectors.toList()); List<ConceptSet> conceptSets = workspaceResourceResponse.stream() .map(WorkspaceResource::getConceptSet) .filter(Objects::nonNull) .collect(Collectors.toList()); List<DataSet> dataSets = workspaceResourceResponse.stream() .map(WorkspaceResource::getDataSet) .filter(Objects::nonNull) .collect(Collectors.toList()); assertThat(cohorts).hasSize(1); assertThat(cohorts.get(0)).isEqualTo(cohort); assertThat(cohortReviews).hasSize(1); compareCohortReviewFields(cohortReviews.get(0), cohortReview); assertThat(conceptSets).hasSize(1); assertThat(conceptSets.get(0)).isEqualTo(conceptSet.concepts(null)); assertThat(dataSets).hasSize(1); compareDatasetMetadata(dataSets.get(0), dataSet); } | @Override public ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources( String workspaceNamespace, String workspaceId, WorkspaceResourcesRequest workspaceResourcesRequest) { WorkspaceAccessLevel workspaceAccessLevel = workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, workspaceId, WorkspaceAccessLevel.READER); final DbWorkspace dbWorkspace = workspaceService.getRequiredWithCohorts(workspaceNamespace, workspaceId); WorkspaceResourceResponse workspaceResourceResponse = new WorkspaceResourceResponse(); workspaceResourceResponse.addAll( workspaceResourcesService.getWorkspaceResources( dbWorkspace, workspaceAccessLevel, workspaceResourcesRequest.getTypesToFetch())); return ResponseEntity.ok(workspaceResourceResponse); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources( String workspaceNamespace, String workspaceId, WorkspaceResourcesRequest workspaceResourcesRequest) { WorkspaceAccessLevel workspaceAccessLevel = workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, workspaceId, WorkspaceAccessLevel.READER); final DbWorkspace dbWorkspace = workspaceService.getRequiredWithCohorts(workspaceNamespace, workspaceId); WorkspaceResourceResponse workspaceResourceResponse = new WorkspaceResourceResponse(); workspaceResourceResponse.addAll( workspaceResourcesService.getWorkspaceResources( dbWorkspace, workspaceAccessLevel, workspaceResourcesRequest.getTypesToFetch())); return ResponseEntity.ok(workspaceResourceResponse); } } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources( String workspaceNamespace, String workspaceId, WorkspaceResourcesRequest workspaceResourcesRequest) { WorkspaceAccessLevel workspaceAccessLevel = workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, workspaceId, WorkspaceAccessLevel.READER); final DbWorkspace dbWorkspace = workspaceService.getRequiredWithCohorts(workspaceNamespace, workspaceId); WorkspaceResourceResponse workspaceResourceResponse = new WorkspaceResourceResponse(); workspaceResourceResponse.addAll( workspaceResourcesService.getWorkspaceResources( dbWorkspace, workspaceAccessLevel, workspaceResourcesRequest.getTypesToFetch())); return ResponseEntity.ok(workspaceResourceResponse); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources( String workspaceNamespace, String workspaceId, WorkspaceResourcesRequest workspaceResourcesRequest) { WorkspaceAccessLevel workspaceAccessLevel = workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, workspaceId, WorkspaceAccessLevel.READER); final DbWorkspace dbWorkspace = workspaceService.getRequiredWithCohorts(workspaceNamespace, workspaceId); WorkspaceResourceResponse workspaceResourceResponse = new WorkspaceResourceResponse(); workspaceResourceResponse.addAll( workspaceResourcesService.getWorkspaceResources( dbWorkspace, workspaceAccessLevel, workspaceResourcesRequest.getTypesToFetch())); return ResponseEntity.ok(workspaceResourceResponse); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } | WorkspacesController implements WorkspacesApiDelegate { @Override public ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources( String workspaceNamespace, String workspaceId, WorkspaceResourcesRequest workspaceResourcesRequest) { WorkspaceAccessLevel workspaceAccessLevel = workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, workspaceId, WorkspaceAccessLevel.READER); final DbWorkspace dbWorkspace = workspaceService.getRequiredWithCohorts(workspaceNamespace, workspaceId); WorkspaceResourceResponse workspaceResourceResponse = new WorkspaceResourceResponse(); workspaceResourceResponse.addAll( workspaceResourcesService.getWorkspaceResources( dbWorkspace, workspaceAccessLevel, workspaceResourcesRequest.getTypesToFetch())); return ResponseEntity.ok(workspaceResourceResponse); } @Autowired WorkspacesController(
BillingProjectBufferService billingProjectBufferService,
CdrVersionDao cdrVersionDao,
Clock clock,
CloudStorageService cloudStorageService,
FireCloudService fireCloudService,
FreeTierBillingService freeTierBillingService,
LogsBasedMetricService logsBasedMetricService,
NotebooksService notebooksService,
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserService userService,
WorkspaceAuditor workspaceAuditor,
WorkspaceMapper workspaceMapper,
WorkspaceResourcesService workspaceResourcesService,
WorkspaceService workspaceService); @Override ResponseEntity<Workspace> createWorkspace(Workspace workspace); @Override ResponseEntity<EmptyResponse> deleteWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponse> getWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getWorkspaces(); @Override ResponseEntity<Workspace> updateWorkspace(
String workspaceNamespace, String workspaceId, UpdateWorkspaceRequest request); @Override ResponseEntity<CloneWorkspaceResponse> cloneWorkspace(
String fromWorkspaceNamespace, String fromWorkspaceId, CloneWorkspaceRequest body); @Override ResponseEntity<WorkspaceBillingUsageResponse> getBillingUsage(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceUserRolesResponse> shareWorkspace(
String workspaceNamespace, String workspaceId, ShareWorkspaceRequest request); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<EmptyResponse> reviewWorkspace(
String ns, String id, ResearchPurposeReviewRequest review); @Override @AuthorityRequired({Authority.REVIEW_RESEARCH_PURPOSE}) ResponseEntity<WorkspaceListResponse> getWorkspacesForReview(); @Override ResponseEntity<List<FileDetail>> getNoteBookList(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<EmptyResponse> deleteNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> copyNotebook(
String fromWorkspaceNamespace,
String fromWorkspaceId,
String fromNotebookName,
CopyRequest copyRequest); @Override ResponseEntity<FileDetail> cloneNotebook(
String workspace, String workspaceName, String notebookName); @Override ResponseEntity<FileDetail> renameNotebook(
String workspace, String workspaceName, NotebookRename rename); @Override ResponseEntity<Workspace> markResearchPurposeReviewed(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<ReadOnlyNotebookResponse> readOnlyNotebook(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<NotebookLockingMetadataResponse> getNotebookLockingMetadata(
String workspaceNamespace, String workspaceName, String notebookName); @Override ResponseEntity<WorkspaceUserRolesResponse> getFirecloudWorkspaceUserRoles(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResponseListResponse> getPublishedWorkspaces(); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> publishWorkspace(
String workspaceNamespace, String workspaceId); @Override @AuthorityRequired({Authority.FEATURED_WORKSPACE_ADMIN}) ResponseEntity<EmptyResponse> unpublishWorkspace(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<RecentWorkspaceResponse> getUserRecentWorkspaces(); @Override ResponseEntity<RecentWorkspaceResponse> updateRecentWorkspaces(
String workspaceNamespace, String workspaceId); @Override ResponseEntity<WorkspaceResourceResponse> getWorkspaceResources(
String workspaceNamespace,
String workspaceId,
WorkspaceResourcesRequest workspaceResourcesRequest); } |
@Test public void testGetStatusAlert() { StatusAlert statusAlert = statusAlertController.getStatusAlert().getBody(); assertThat(statusAlert.getTitle()).matches(STATUS_ALERT_INITIAL_TITLE); assertThat(statusAlert.getMessage()).matches(STATUS_ALERT_INITIAL_DESCRIPTION); } | @Override public ResponseEntity<StatusAlert> getStatusAlert() { Optional<DbStatusAlert> dbStatusAlertOptional = statusAlertDao.findFirstByOrderByStatusAlertIdDesc(); if (dbStatusAlertOptional.isPresent()) { DbStatusAlert dbStatusAlert = dbStatusAlertOptional.get(); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } else { return ResponseEntity.ok(new StatusAlert()); } } | StatusAlertController implements StatusAlertApiDelegate { @Override public ResponseEntity<StatusAlert> getStatusAlert() { Optional<DbStatusAlert> dbStatusAlertOptional = statusAlertDao.findFirstByOrderByStatusAlertIdDesc(); if (dbStatusAlertOptional.isPresent()) { DbStatusAlert dbStatusAlert = dbStatusAlertOptional.get(); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } else { return ResponseEntity.ok(new StatusAlert()); } } } | StatusAlertController implements StatusAlertApiDelegate { @Override public ResponseEntity<StatusAlert> getStatusAlert() { Optional<DbStatusAlert> dbStatusAlertOptional = statusAlertDao.findFirstByOrderByStatusAlertIdDesc(); if (dbStatusAlertOptional.isPresent()) { DbStatusAlert dbStatusAlert = dbStatusAlertOptional.get(); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } else { return ResponseEntity.ok(new StatusAlert()); } } @Autowired StatusAlertController(StatusAlertDao statusAlertDao); } | StatusAlertController implements StatusAlertApiDelegate { @Override public ResponseEntity<StatusAlert> getStatusAlert() { Optional<DbStatusAlert> dbStatusAlertOptional = statusAlertDao.findFirstByOrderByStatusAlertIdDesc(); if (dbStatusAlertOptional.isPresent()) { DbStatusAlert dbStatusAlert = dbStatusAlertOptional.get(); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } else { return ResponseEntity.ok(new StatusAlert()); } } @Autowired StatusAlertController(StatusAlertDao statusAlertDao); @Override ResponseEntity<StatusAlert> getStatusAlert(); @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert); } | StatusAlertController implements StatusAlertApiDelegate { @Override public ResponseEntity<StatusAlert> getStatusAlert() { Optional<DbStatusAlert> dbStatusAlertOptional = statusAlertDao.findFirstByOrderByStatusAlertIdDesc(); if (dbStatusAlertOptional.isPresent()) { DbStatusAlert dbStatusAlert = dbStatusAlertOptional.get(); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } else { return ResponseEntity.ok(new StatusAlert()); } } @Autowired StatusAlertController(StatusAlertDao statusAlertDao); @Override ResponseEntity<StatusAlert> getStatusAlert(); @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert); } |
@Test public void checkFreeTierBillingUsage_workspaceMissingCreatorNoNPE() { workbenchConfig.billing.defaultFreeCreditsDollarLimit = 100.0; doReturn(mockBQTableSingleResult(49.99)).when(bigQueryService).executeQuery(any()); final DbUser user = createUser(SINGLE_WORKSPACE_TEST_USER); final DbWorkspace workspace = createWorkspace(user, SINGLE_WORKSPACE_TEST_PROJECT); createWorkspace(null, "rumney"); freeTierBillingService.checkFreeTierBillingUsage(); verifyZeroInteractions(mailService); assertSingleWorkspaceTestDbState(user, workspace, BillingStatus.ACTIVE, 49.99); } | public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } |
@Test public void testStatus_handleJsonException() throws ApiException { when(statusApi.status()).thenThrow(new ApiException(500, null, "unparseable response")); assertThat(service.getFirecloudStatus()).isFalse(); } | @Override public boolean getFirecloudStatus() { try { statusApiProvider.get().status(); } catch (ApiException e) { log.log(Level.WARNING, "Firecloud status check request failed", e); String response = e.getResponseBody(); try { JSONObject errorBody = new JSONObject(response); JSONObject subSystemStatus = errorBody.getJSONObject(STATUS_SUBSYSTEMS_KEY); if (subSystemStatus != null) { return systemOkay(subSystemStatus, THURLOE_STATUS_NAME) && systemOkay(subSystemStatus, SAM_STATUS_NAME) && systemOkay(subSystemStatus, RAWLS_STATUS_NAME) && systemOkay(subSystemStatus, GOOGLE_BUCKETS_STATUS_NAME); } } catch (JSONException ignored) { } return false; } return true; } | FireCloudServiceImpl implements FireCloudService { @Override public boolean getFirecloudStatus() { try { statusApiProvider.get().status(); } catch (ApiException e) { log.log(Level.WARNING, "Firecloud status check request failed", e); String response = e.getResponseBody(); try { JSONObject errorBody = new JSONObject(response); JSONObject subSystemStatus = errorBody.getJSONObject(STATUS_SUBSYSTEMS_KEY); if (subSystemStatus != null) { return systemOkay(subSystemStatus, THURLOE_STATUS_NAME) && systemOkay(subSystemStatus, SAM_STATUS_NAME) && systemOkay(subSystemStatus, RAWLS_STATUS_NAME) && systemOkay(subSystemStatus, GOOGLE_BUCKETS_STATUS_NAME); } } catch (JSONException ignored) { } return false; } return true; } } | FireCloudServiceImpl implements FireCloudService { @Override public boolean getFirecloudStatus() { try { statusApiProvider.get().status(); } catch (ApiException e) { log.log(Level.WARNING, "Firecloud status check request failed", e); String response = e.getResponseBody(); try { JSONObject errorBody = new JSONObject(response); JSONObject subSystemStatus = errorBody.getJSONObject(STATUS_SUBSYSTEMS_KEY); if (subSystemStatus != null) { return systemOkay(subSystemStatus, THURLOE_STATUS_NAME) && systemOkay(subSystemStatus, SAM_STATUS_NAME) && systemOkay(subSystemStatus, RAWLS_STATUS_NAME) && systemOkay(subSystemStatus, GOOGLE_BUCKETS_STATUS_NAME); } } catch (JSONException ignored) { } return false; } return true; } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); } | FireCloudServiceImpl implements FireCloudService { @Override public boolean getFirecloudStatus() { try { statusApiProvider.get().status(); } catch (ApiException e) { log.log(Level.WARNING, "Firecloud status check request failed", e); String response = e.getResponseBody(); try { JSONObject errorBody = new JSONObject(response); JSONObject subSystemStatus = errorBody.getJSONObject(STATUS_SUBSYSTEMS_KEY); if (subSystemStatus != null) { return systemOkay(subSystemStatus, THURLOE_STATUS_NAME) && systemOkay(subSystemStatus, SAM_STATUS_NAME) && systemOkay(subSystemStatus, RAWLS_STATUS_NAME) && systemOkay(subSystemStatus, GOOGLE_BUCKETS_STATUS_NAME); } } catch (JSONException ignored) { } return false; } return true; } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); ApiClient getApiClientWithImpersonation(String userEmail); @Override @VisibleForTesting String getApiBasePath(); @Override boolean getFirecloudStatus(); @Override FirecloudMe getMe(); @Override void registerUser(String contactEmail, String firstName, String lastName); @Override void createAllOfUsBillingProject(String projectName); @Override void deleteBillingProject(String billingProject); @Override FirecloudBillingProjectStatus getBillingProjectStatus(String projectName); @Override void addOwnerToBillingProject(String ownerEmail, String projectName); @Override void removeOwnerFromBillingProject(
String ownerEmailToRemove, String projectName, Optional<String> callerAccessToken); @Override FirecloudWorkspace createWorkspace(String projectName, String workspaceName); @Override FirecloudWorkspace cloneWorkspace(
String fromProject, String fromName, String toProject, String toName); @Override List<FirecloudBillingProjectMembership> getBillingProjectMemberships(); @Override FirecloudWorkspaceACLUpdateResponseList updateWorkspaceACL(
String projectName, String workspaceName, List<FirecloudWorkspaceACLUpdate> aclUpdates); @Override FirecloudWorkspaceACL getWorkspaceAclAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspaceAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspace(String projectName, String workspaceName); @Override Optional<FirecloudWorkspaceResponse> getWorkspace(DbWorkspace dbWorkspace); @Override List<FirecloudWorkspaceResponse> getWorkspaces(); @Override void deleteWorkspace(String projectName, String workspaceName); @Override FirecloudManagedGroupWithMembers getGroup(String groupName); @Override FirecloudManagedGroupWithMembers createGroup(String groupName); @Override void addUserToGroup(String email, String groupName); @Override void removeUserFromGroup(String email, String groupName); @Override boolean isUserMemberOfGroup(String email, String groupName); @Override String staticNotebooksConvert(byte[] notebook); @Override String staticNotebooksConvertAsService(byte[] notebook); @Override FirecloudNihStatus getNihStatus(); @Override void postNihCallback(FirecloudJWTWrapper wrapper); } | FireCloudServiceImpl implements FireCloudService { @Override public boolean getFirecloudStatus() { try { statusApiProvider.get().status(); } catch (ApiException e) { log.log(Level.WARNING, "Firecloud status check request failed", e); String response = e.getResponseBody(); try { JSONObject errorBody = new JSONObject(response); JSONObject subSystemStatus = errorBody.getJSONObject(STATUS_SUBSYSTEMS_KEY); if (subSystemStatus != null) { return systemOkay(subSystemStatus, THURLOE_STATUS_NAME) && systemOkay(subSystemStatus, SAM_STATUS_NAME) && systemOkay(subSystemStatus, RAWLS_STATUS_NAME) && systemOkay(subSystemStatus, GOOGLE_BUCKETS_STATUS_NAME); } } catch (JSONException ignored) { } return false; } return true; } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); ApiClient getApiClientWithImpersonation(String userEmail); @Override @VisibleForTesting String getApiBasePath(); @Override boolean getFirecloudStatus(); @Override FirecloudMe getMe(); @Override void registerUser(String contactEmail, String firstName, String lastName); @Override void createAllOfUsBillingProject(String projectName); @Override void deleteBillingProject(String billingProject); @Override FirecloudBillingProjectStatus getBillingProjectStatus(String projectName); @Override void addOwnerToBillingProject(String ownerEmail, String projectName); @Override void removeOwnerFromBillingProject(
String ownerEmailToRemove, String projectName, Optional<String> callerAccessToken); @Override FirecloudWorkspace createWorkspace(String projectName, String workspaceName); @Override FirecloudWorkspace cloneWorkspace(
String fromProject, String fromName, String toProject, String toName); @Override List<FirecloudBillingProjectMembership> getBillingProjectMemberships(); @Override FirecloudWorkspaceACLUpdateResponseList updateWorkspaceACL(
String projectName, String workspaceName, List<FirecloudWorkspaceACLUpdate> aclUpdates); @Override FirecloudWorkspaceACL getWorkspaceAclAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspaceAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspace(String projectName, String workspaceName); @Override Optional<FirecloudWorkspaceResponse> getWorkspace(DbWorkspace dbWorkspace); @Override List<FirecloudWorkspaceResponse> getWorkspaces(); @Override void deleteWorkspace(String projectName, String workspaceName); @Override FirecloudManagedGroupWithMembers getGroup(String groupName); @Override FirecloudManagedGroupWithMembers createGroup(String groupName); @Override void addUserToGroup(String email, String groupName); @Override void removeUserFromGroup(String email, String groupName); @Override boolean isUserMemberOfGroup(String email, String groupName); @Override String staticNotebooksConvert(byte[] notebook); @Override String staticNotebooksConvertAsService(byte[] notebook); @Override FirecloudNihStatus getNihStatus(); @Override void postNihCallback(FirecloudJWTWrapper wrapper); static final List<String> FIRECLOUD_API_OAUTH_SCOPES; static final List<String> FIRECLOUD_WORKSPACE_REQUIRED_FIELDS; } |
@Test public void testPostStatusAlert() { String updatedStatusAlertTitle = "Title 2"; String updatedStatusAlertDescription = "Description 2"; String updatedStatusAlertLink = "This has a link"; StatusAlert statusAlert = new StatusAlert() .title(updatedStatusAlertTitle) .message(updatedStatusAlertDescription) .link(updatedStatusAlertLink); statusAlertController.postStatusAlert(statusAlert); StatusAlert updatedStatusAlert = statusAlertController.getStatusAlert().getBody(); assertThat(updatedStatusAlert.getTitle()).matches(updatedStatusAlertTitle); assertThat(updatedStatusAlert.getMessage()).matches(updatedStatusAlertDescription); assertThat(updatedStatusAlert.getLink()).matches(updatedStatusAlertLink); } | @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) public ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert) { Iterable<DbStatusAlert> dbStatusAlertList = statusAlertDao.findAll(); dbStatusAlertList.forEach( statusAlert1 -> statusAlertDao.delete(statusAlert1.getStatusAlertId())); DbStatusAlert dbStatusAlert = statusAlertDao.save(StatusAlertConversionUtils.toDbStatusAlert(statusAlert)); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } | StatusAlertController implements StatusAlertApiDelegate { @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) public ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert) { Iterable<DbStatusAlert> dbStatusAlertList = statusAlertDao.findAll(); dbStatusAlertList.forEach( statusAlert1 -> statusAlertDao.delete(statusAlert1.getStatusAlertId())); DbStatusAlert dbStatusAlert = statusAlertDao.save(StatusAlertConversionUtils.toDbStatusAlert(statusAlert)); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } } | StatusAlertController implements StatusAlertApiDelegate { @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) public ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert) { Iterable<DbStatusAlert> dbStatusAlertList = statusAlertDao.findAll(); dbStatusAlertList.forEach( statusAlert1 -> statusAlertDao.delete(statusAlert1.getStatusAlertId())); DbStatusAlert dbStatusAlert = statusAlertDao.save(StatusAlertConversionUtils.toDbStatusAlert(statusAlert)); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } @Autowired StatusAlertController(StatusAlertDao statusAlertDao); } | StatusAlertController implements StatusAlertApiDelegate { @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) public ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert) { Iterable<DbStatusAlert> dbStatusAlertList = statusAlertDao.findAll(); dbStatusAlertList.forEach( statusAlert1 -> statusAlertDao.delete(statusAlert1.getStatusAlertId())); DbStatusAlert dbStatusAlert = statusAlertDao.save(StatusAlertConversionUtils.toDbStatusAlert(statusAlert)); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } @Autowired StatusAlertController(StatusAlertDao statusAlertDao); @Override ResponseEntity<StatusAlert> getStatusAlert(); @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert); } | StatusAlertController implements StatusAlertApiDelegate { @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) public ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert) { Iterable<DbStatusAlert> dbStatusAlertList = statusAlertDao.findAll(); dbStatusAlertList.forEach( statusAlert1 -> statusAlertDao.delete(statusAlert1.getStatusAlertId())); DbStatusAlert dbStatusAlert = statusAlertDao.save(StatusAlertConversionUtils.toDbStatusAlert(statusAlert)); return ResponseEntity.ok(StatusAlertConversionUtils.toApiStatusAlert(dbStatusAlert)); } @Autowired StatusAlertController(StatusAlertDao statusAlertDao); @Override ResponseEntity<StatusAlert> getStatusAlert(); @Override @AuthorityRequired(Authority.COMMUNICATIONS_ADMIN) ResponseEntity<StatusAlert> postStatusAlert(StatusAlert statusAlert); } |
@Test public void testGetCdrVersionsRegistered() { assertResponse(cdrVersionsController.getCdrVersions().getBody(), defaultCdrVersion); } | @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); @Override ResponseEntity<CdrVersionListResponse> getCdrVersions(); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); @Override ResponseEntity<CdrVersionListResponse> getCdrVersions(); } |
@Test public void testGetCdrVersions_microarray() { user.setDataAccessLevelEnum(DataAccessLevel.PROTECTED); List<CdrVersion> cdrVersions = cdrVersionsController.getCdrVersions().getBody().getItems(); assertThat( cdrVersions.stream() .filter(v -> v.getName().equals("Test Registered CDR")) .findFirst() .get() .getHasMicroarrayData()) .isFalse(); assertThat( cdrVersions.stream() .filter(v -> v.getName().equals("Test Protected CDR")) .findFirst() .get() .getHasMicroarrayData()) .isTrue(); } | @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); @Override ResponseEntity<CdrVersionListResponse> getCdrVersions(); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); @Override ResponseEntity<CdrVersionListResponse> getCdrVersions(); } |
@Test public void testGetCdrVersionsProtected() { user.setDataAccessLevelEnum(DataAccessLevel.PROTECTED); assertResponse( cdrVersionsController.getCdrVersions().getBody(), protectedCdrVersion, defaultCdrVersion); } | @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); @Override ResponseEntity<CdrVersionListResponse> getCdrVersions(); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); @Override ResponseEntity<CdrVersionListResponse> getCdrVersions(); } |
@Test(expected = ForbiddenException.class) public void testGetCdrVersionsUnregistered() { user.setDataAccessLevelEnum(DataAccessLevel.UNREGISTERED); cdrVersionsController.getCdrVersions(); } | @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); @Override ResponseEntity<CdrVersionListResponse> getCdrVersions(); } | CdrVersionsController implements CdrVersionsApiDelegate { @Override public ResponseEntity<CdrVersionListResponse> getCdrVersions() { DataAccessLevel accessLevel = userProvider.get().getDataAccessLevelEnum(); List<DbCdrVersion> cdrVersions = cdrVersionService.findAuthorizedCdrVersions(accessLevel); if (cdrVersions.isEmpty()) { throw new ForbiddenException("User does not have access to any CDR versions"); } List<Long> defaultVersions = cdrVersions.stream() .filter(v -> v.getIsDefault()) .map(DbCdrVersion::getCdrVersionId) .collect(Collectors.toList()); if (defaultVersions.isEmpty()) { throw new ForbiddenException("User does not have access to a default CDR version"); } if (defaultVersions.size() > 1) { log.severe( String.format( "Found multiple (%d) default CDR versions, picking one", defaultVersions.size())); } return ResponseEntity.ok( new CdrVersionListResponse() .items( cdrVersions.stream() .map(cdrVersionMapper::dbModelToClient) .collect(Collectors.toList())) .defaultCdrVersionId(Long.toString(defaultVersions.get(0)))); } @Autowired CdrVersionsController(
CdrVersionService cdrVersionService,
CdrVersionMapper cdrVersionMapper,
Provider<DbUser> userProvider); @Override ResponseEntity<CdrVersionListResponse> getCdrVersions(); } |
@Test public void testAuditTableSuffix() { assertThat(OfflineAuditController.auditTableSuffix(Instant.parse("2007-01-03T00:00:00.00Z"), 0)) .isEqualTo("20070103"); assertThat(OfflineAuditController.auditTableSuffix(Instant.parse("2018-01-01T23:59:59.00Z"), 3)) .isEqualTo("20171229"); } | @VisibleForTesting static String auditTableSuffix(Instant now, int daysAgo) { Instant target = now.minus(daysAgo, ChronoUnit.DAYS); return auditTableNameDateFormatter.withZone(ZoneId.of("UTC")).format(target); } | OfflineAuditController implements OfflineAuditApiDelegate { @VisibleForTesting static String auditTableSuffix(Instant now, int daysAgo) { Instant target = now.minus(daysAgo, ChronoUnit.DAYS); return auditTableNameDateFormatter.withZone(ZoneId.of("UTC")).format(target); } } | OfflineAuditController implements OfflineAuditApiDelegate { @VisibleForTesting static String auditTableSuffix(Instant now, int daysAgo) { Instant target = now.minus(daysAgo, ChronoUnit.DAYS); return auditTableNameDateFormatter.withZone(ZoneId.of("UTC")).format(target); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); } | OfflineAuditController implements OfflineAuditApiDelegate { @VisibleForTesting static String auditTableSuffix(Instant now, int daysAgo) { Instant target = now.minus(daysAgo, ChronoUnit.DAYS); return auditTableNameDateFormatter.withZone(ZoneId.of("UTC")).format(target); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); @Override ResponseEntity<AuditBigQueryResponse> auditBigQuery(); } | OfflineAuditController implements OfflineAuditApiDelegate { @VisibleForTesting static String auditTableSuffix(Instant now, int daysAgo) { Instant target = now.minus(daysAgo, ChronoUnit.DAYS); return auditTableNameDateFormatter.withZone(ZoneId.of("UTC")).format(target); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); @Override ResponseEntity<AuditBigQueryResponse> auditBigQuery(); } |
@Test public void testAuditBigQueryCdrV1Queries() { stubBigQueryCalls(CDR_V1_PROJECT_ID, USER_EMAIL, 5); assertThat(offlineAuditController.auditBigQuery().getBody().getNumQueryIssues()).isEqualTo(0); } | @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); @Override ResponseEntity<AuditBigQueryResponse> auditBigQuery(); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); @Override ResponseEntity<AuditBigQueryResponse> auditBigQuery(); } |
@Test public void testAuditBigQueryCdrV2Queries() { stubBigQueryCalls(CDR_V2_PROJECT_ID, USER_EMAIL, 5); assertThat(offlineAuditController.auditBigQuery().getBody().getNumQueryIssues()).isEqualTo(0); } | @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); @Override ResponseEntity<AuditBigQueryResponse> auditBigQuery(); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); @Override ResponseEntity<AuditBigQueryResponse> auditBigQuery(); } |
@Test public void testAuditBigQueryFirecloudQueries() { stubBigQueryCalls(FC_PROJECT_ID, USER_EMAIL, 5); assertThat(offlineAuditController.auditBigQuery().getBody().getNumQueryIssues()).isEqualTo(0); } | @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); @Override ResponseEntity<AuditBigQueryResponse> auditBigQuery(); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); @Override ResponseEntity<AuditBigQueryResponse> auditBigQuery(); } |
@Test public void testAuditBigQueryUnrecognizedProjectQueries() { stubBigQueryCalls("my-personal-gcp-project", USER_EMAIL, 5); assertThat(offlineAuditController.auditBigQuery().getBody().getNumQueryIssues()).isEqualTo(10); } | @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); @Override ResponseEntity<AuditBigQueryResponse> auditBigQuery(); } | OfflineAuditController implements OfflineAuditApiDelegate { @Override public ResponseEntity<AuditBigQueryResponse> auditBigQuery() { Set<String> cdrProjects = ImmutableList.copyOf(cdrVersionDao.findAll()).stream() .map(v -> v.getBigqueryProject()) .collect(Collectors.toSet()); Set<String> whitelist = Sets.union(workspaceDao.findAllWorkspaceNamespaces(), cdrProjects); Instant now = clock.instant(); List<String> suffixes = IntStream.range(0, AUDIT_DAY_RANGE) .mapToObj(i -> auditTableSuffix(now, i)) .collect(Collectors.toList()); int numBad = 0; int numQueries = 0; for (String cdrProjectId : cdrProjects) { TableResult result = bigQueryService.executeQuery(QueryJobConfiguration.of(auditSql(cdrProjectId, suffixes))); Map<String, Integer> rm = bigQueryService.getResultMapper(result); for (List<FieldValue> row : result.iterateAll()) { String project_id = bigQueryService.getString(row, rm.get("client_project_id")); String email = bigQueryService.getString(row, rm.get("user_email")); long total = bigQueryService.getLong(row, rm.get("total")); if (bigQueryService.isNull(row, rm.get("client_project_id"))) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries with missing project ID from user '%s'; " + "indicates an ACL misconfiguration, this user can access the CDR but is not a " + "project jobUser", cdrProjectId, total, email)); numBad += total; } else if (!whitelist.contains(project_id)) { log.severe( String.format( "AUDIT: (CDR project '%s') %d queries in unrecognized project '%s' from user '%s'", cdrProjectId, total, project_id, email)); numBad += total; } numQueries += total; } } log.info( String.format("AUDIT: found audit issues with %d/%d BigQuery queries", numBad, numQueries)); return ResponseEntity.ok(new AuditBigQueryResponse().numQueryIssues(numBad)); } @Autowired OfflineAuditController(
Clock clock,
BigQueryService bigQueryService,
CdrVersionDao cdrVersionDao,
WorkspaceDao workspaceDao); @Override ResponseEntity<AuditBigQueryResponse> auditBigQuery(); } |
@Test public void checkFreeTierBillingUsage_combinedProjectsExceedsLimit() throws MessagingException { final String ns1 = "namespace-1"; final String ns2 = "namespace-2"; final double cost1 = 123.45; final double cost2 = 234.56; final double sum = cost1 + cost2; workbenchConfig.billing.defaultFreeCreditsDollarLimit = sum - 0.01; doReturn(mockBQTableResult(ImmutableMap.of(ns1, cost1, ns2, cost2))) .when(bigQueryService) .executeQuery(any()); final DbUser user = createUser(SINGLE_WORKSPACE_TEST_USER); final DbWorkspace ws1 = createWorkspace(user, ns1); final DbWorkspace ws2 = createWorkspace(user, ns2); freeTierBillingService.checkFreeTierBillingUsage(); verify(mailService).alertUserFreeTierExpiration(eq(user)); assertThat(workspaceFreeTierUsageDao.count()).isEqualTo(2); for (DbWorkspace ws : Arrays.asList(ws1, ws2)) { DbWorkspace dbWorkspace = workspaceDao.findOne(ws.getWorkspaceId()); assertThat(dbWorkspace.getBillingStatus()).isEqualTo(BillingStatus.INACTIVE); assertThat(dbWorkspace.getBillingAccountType()).isEqualTo(BillingAccountType.FREE_TIER); } final DbWorkspaceFreeTierUsage usage1 = workspaceFreeTierUsageDao.findOneByWorkspace(ws1); assertThat(usage1.getUser()).isEqualTo(user); assertWithinBillingTolerance(usage1.getCost(), cost1); final DbWorkspaceFreeTierUsage usage2 = workspaceFreeTierUsageDao.findOneByWorkspace(ws2); assertThat(usage2.getUser()).isEqualTo(user); assertWithinBillingTolerance(usage2.getCost(), cost2); } | public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } |
@Test public void testCheckRuntimesNoResults() throws Exception { stubRuntimes(ImmutableList.of()); assertThat(controller.checkRuntimes().getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT); verify(mockRuntimesApi, never()).deleteRuntime(any(), any(), any()); } | @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } |
@Test public void testCheckRuntimesActiveRuntime() throws Exception { stubRuntimes(ImmutableList.of(runtimeWithAge(Duration.ofHours(10)))); assertThat(controller.checkRuntimes().getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT); verify(mockRuntimesApi, never()).deleteRuntime(any(), any(), any()); } | @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } |
@Test public void testCheckRuntimesActiveTooOld() throws Exception { stubRuntimes(ImmutableList.of(runtimeWithAge(MAX_AGE.plusMinutes(5)))); assertThat(controller.checkRuntimes().getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT); verify(mockRuntimesApi).deleteRuntime(any(), any(), any()); } | @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } |
@Test public void testCheckRuntimesIdleYoung() throws Exception { stubRuntimes( ImmutableList.of( runtimeWithAgeAndIdle(IDLE_MAX_AGE.minusMinutes(10), Duration.ofHours(10)))); assertThat(controller.checkRuntimes().getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT); verify(mockRuntimesApi, never()).deleteRuntime(any(), any(), any()); } | @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } |
@Test public void testCheckRuntimesIdleOld() throws Exception { stubRuntimes( ImmutableList.of( runtimeWithAgeAndIdle(IDLE_MAX_AGE.plusMinutes(15), Duration.ofHours(10)))); assertThat(controller.checkRuntimes().getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT); verify(mockRuntimesApi).deleteRuntime(any(), any(), any()); } | @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } |
@Test public void testCheckRuntimesBrieflyIdleOld() throws Exception { stubRuntimes( ImmutableList.of( runtimeWithAgeAndIdle(IDLE_MAX_AGE.plusMinutes(15), Duration.ofMinutes(15)))); assertThat(controller.checkRuntimes().getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT); verify(mockRuntimesApi, never()).deleteRuntime(any(), any(), any()); } | @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } |
@Test public void testCheckRuntimesOtherStatusFiltered() throws Exception { stubRuntimes( ImmutableList.of( runtimeWithAge(MAX_AGE.plusDays(10)).status(LeonardoRuntimeStatus.DELETING))); assertThat(controller.checkRuntimes().getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT); verify(mockRuntimesApi, never()).deleteRuntime(any(), any(), any()); } | @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } | OfflineRuntimeController implements OfflineRuntimeApiDelegate { @Override public ResponseEntity<Void> checkRuntimes() { final Instant now = clock.instant(); final WorkbenchConfig config = configProvider.get(); final Duration maxAge = Duration.ofDays(config.firecloud.notebookRuntimeMaxAgeDays); final Duration idleMaxAge = Duration.ofDays(config.firecloud.notebookRuntimeIdleMaxAgeDays); final RuntimesApi runtimesApi = runtimesApiProvider.get(); final List<LeonardoListRuntimeResponse> listRuntimeResponses; try { listRuntimeResponses = runtimesApi.listRuntimes(null, false); } catch (ApiException e) { throw ExceptionUtils.convertLeonardoException(e); } int errors = 0; int idles = 0; int activeDeletes = 0; int unusedDeletes = 0; for (LeonardoListRuntimeResponse listRuntimeResponse : listRuntimeResponses) { final String runtimeId = listRuntimeResponse.getGoogleProject() + "/" + listRuntimeResponse.getRuntimeName(); final LeonardoGetRuntimeResponse runtime; try { runtime = runtimesApi.getRuntime( listRuntimeResponse.getGoogleProject(), listRuntimeResponse.getRuntimeName()); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to refetch runtime '%s'", runtimeId), e); errors++; continue; } if (LeonardoRuntimeStatus.UNKNOWN.equals(runtime.getStatus()) || runtime.getStatus() == null) { log.warning(String.format("unknown runtime status for runtime '%s'", runtimeId)); continue; } if (!LeonardoRuntimeStatus.RUNNING.equals(runtime.getStatus()) && !LeonardoRuntimeStatus.STOPPED.equals(runtime.getStatus())) { continue; } final Instant lastUsed = Instant.parse(runtime.getAuditInfo().getDateAccessed()); final boolean isIdle = Duration.between(lastUsed, now).toHours() > IDLE_AFTER_HOURS; if (isIdle) { idles++; } final Instant created = Instant.parse(runtime.getAuditInfo().getCreatedDate()); final Duration age = Duration.between(created, now); if (age.toMillis() > maxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', exceeded max lifetime @ %s (>%s)", runtimeId, formatDuration(age), formatDuration(maxAge))); activeDeletes++; } else if (isIdle && age.toMillis() > idleMaxAge.toMillis()) { log.info( String.format( "deleting runtime '%s', idle with age %s (>%s)", runtimeId, formatDuration(age), formatDuration(idleMaxAge))); unusedDeletes++; } else { continue; } try { runtimesApi.deleteRuntime( runtime.getGoogleProject(), runtime.getRuntimeName(), false); } catch (ApiException e) { log.log(Level.WARNING, String.format("failed to delete runtime '%s'", runtimeId), e); errors++; } } log.info( String.format( "deleted %d old runtimes and %d idle runtimes (with %d errors) " + "of %d total runtimes (%d of which were idle)", activeDeletes, unusedDeletes, errors, listRuntimeResponses.size(), idles)); if (errors > 0) { throw new ServerErrorException(String.format("%d runtime deletion calls failed", errors)); } return ResponseEntity.noContent().build(); } @Autowired OfflineRuntimeController(
@Qualifier(NotebooksConfig.SERVICE_RUNTIMES_API) Provider<RuntimesApi> runtimesApiProvider,
Provider<WorkbenchConfig> configProvider,
Clock clock); @Override ResponseEntity<Void> checkRuntimes(); } |
@Test(expected = ForbiddenException.class) public void testUnregistered() { when(fireCloudService.isUserMemberOfGroup(any(), any())).thenReturn(false); userController.user("Robinson", null, null, null).getBody(); } | @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void testUserSearch() { when(fireCloudService.isUserMemberOfGroup(any(), any())).thenReturn(true); DbUser john = userDao.findUserByUsername("[email protected]"); UserResponse response = userController.user("John", null, null, null).getBody(); assertThat(response.getUsers()).hasSize(1); assertThat(response.getUsers().get(0).getEmail()).isSameAs(john.getUsername()); assertThat(response.getUsers().get(0).getUserName()).isSameAs(john.getUsername()); } | @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void testUserPartialStringSearch() { when(fireCloudService.isUserMemberOfGroup(any(), any())).thenReturn(true); List<DbUser> allUsers = Lists.newArrayList(userDao.findAll()); UserResponse response = userController.user("obin", null, null, null).getBody(); assertThat(response.getUsers()).hasSize(5); } | @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void checkFreeTierBillingUsage_twoUsers() throws MessagingException { final String ns1 = "namespace-1"; final String ns2 = "namespace-2"; final double cost1 = 123.45; final double cost2 = 234.56; workbenchConfig.billing.defaultFreeCreditsDollarLimit = Math.min(cost1, cost2) - 0.01; doReturn(mockBQTableResult(ImmutableMap.of(ns1, cost1, ns2, cost2))) .when(bigQueryService) .executeQuery(any()); DbUser user1 = createUser(SINGLE_WORKSPACE_TEST_USER); DbWorkspace ws1 = createWorkspace(user1, ns1); DbUser user2 = createUser("[email protected]"); DbWorkspace ws2 = createWorkspace(user2, ns2); freeTierBillingService.checkFreeTierBillingUsage(); verify(mailService).alertUserFreeTierExpiration(eq(user1)); verify(mailService).alertUserFreeTierExpiration(eq(user2)); assertThat(workspaceFreeTierUsageDao.count()).isEqualTo(2); final DbWorkspace dbWorkspace1 = workspaceDao.findOne(ws1.getWorkspaceId()); assertThat(dbWorkspace1.getBillingStatus()).isEqualTo(BillingStatus.INACTIVE); assertThat(dbWorkspace1.getBillingAccountType()).isEqualTo(BillingAccountType.FREE_TIER); final DbWorkspaceFreeTierUsage usage1 = workspaceFreeTierUsageDao.findOneByWorkspace(ws1); assertThat(usage1.getUser()).isEqualTo(user1); assertWithinBillingTolerance(usage1.getCost(), cost1); final DbWorkspace dbWorkspace2 = workspaceDao.findOne(ws2.getWorkspaceId()); assertThat(dbWorkspace2.getBillingStatus()).isEqualTo(BillingStatus.INACTIVE); assertThat(dbWorkspace2.getBillingAccountType()).isEqualTo(BillingAccountType.FREE_TIER); final DbWorkspaceFreeTierUsage usage2 = workspaceFreeTierUsageDao.findOneByWorkspace(ws2); assertThat(usage2.getUser()).isEqualTo(user2); assertWithinBillingTolerance(usage2.getCost(), cost2); } | public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } |
@Test public void testUserEmptyResponse() { when(fireCloudService.isUserMemberOfGroup(any(), any())).thenReturn(true); UserResponse response = userController.user("", null, null, null).getBody(); assertThat(response.getUsers()).hasSize(0); } | @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void testUserNoUsersResponse() { when(fireCloudService.isUserMemberOfGroup(any(), any())).thenReturn(true); UserResponse response = userController.user("Smith", null, null, null).getBody(); assertThat(response.getUsers()).hasSize(0); } | @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void testInvalidPageTokenCharacters() { ResponseEntity<UserResponse> response = userController.user("Robinson", "Inv@l!dT0k3n#", null, null); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST); assertThat(response.getBody().getUsers()).hasSize(0); } | @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void testInvalidPageToken() { ResponseEntity<UserResponse> response = userController.user("Robinson", "eyJvZmZzZXQBhcmFtZF9", null, null); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST); assertThat(response.getBody().getUsers()).hasSize(0); } | @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void testNegativePageOffset() { ResponseEntity<UserResponse> response = userController.user("Robinson", PaginationToken.of(-1).toBase64(), null, null); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST); assertThat(response.getBody().getUsers()).hasSize(0); } | @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void testUserPageSize() { when(fireCloudService.isUserMemberOfGroup(any(), any())).thenReturn(true); int size = 1; UserResponse robinsons_0 = userController.user("Robinson", PaginationToken.of(0).toBase64(), size, null).getBody(); UserResponse robinsons_1 = userController.user("Robinson", PaginationToken.of(1).toBase64(), size, null).getBody(); UserResponse robinsons_2 = userController.user("Robinson", PaginationToken.of(2).toBase64(), size, null).getBody(); UserResponse robinsons_3 = userController.user("Robinson", PaginationToken.of(3).toBase64(), size, null).getBody(); UserResponse robinsons_4 = userController.user("Robinson", PaginationToken.of(4).toBase64(), size, null).getBody(); assertThat(robinsons_0.getUsers()).hasSize(size); assertThat(robinsons_0.getNextPageToken()).isEqualTo(PaginationToken.of(1).toBase64()); assertThat(robinsons_1.getUsers()).hasSize(size); assertThat(robinsons_1.getNextPageToken()).isEqualTo(PaginationToken.of(2).toBase64()); assertThat(robinsons_2.getUsers()).hasSize(size); assertThat(robinsons_2.getNextPageToken()).isEqualTo(PaginationToken.of(3).toBase64()); assertThat(robinsons_3.getUsers()).hasSize(size); assertThat(robinsons_3.getNextPageToken()).isEqualTo(PaginationToken.of(4).toBase64()); assertThat(robinsons_4.getUsers()).hasSize(size); assertThat(robinsons_4.getNextPageToken()).isEqualTo(""); } | @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void testUserPagedResponses() { when(fireCloudService.isUserMemberOfGroup(any(), any())).thenReturn(true); UserResponse robinsons_0_1 = userController.user("Robinson", PaginationToken.of(0).toBase64(), 2, null).getBody(); UserResponse robinsons_2_3 = userController.user("Robinson", PaginationToken.of(1).toBase64(), 2, null).getBody(); UserResponse robinsons_4 = userController.user("Robinson", PaginationToken.of(3).toBase64(), 1, null).getBody(); assertThat(robinsons_0_1.getUsers()).hasSize(2); assertThat(robinsons_2_3.getUsers()).hasSize(2); assertThat(robinsons_4.getUsers()).hasSize(1); assertThat(robinsons_0_1.getUsers()).containsNoneOf(robinsons_2_3, robinsons_4); assertThat(robinsons_2_3.getUsers()).containsNoneOf(robinsons_0_1, robinsons_4); assertThat(robinsons_4.getUsers()).containsNoneOf(robinsons_0_1, robinsons_2_3); } | @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void testUserSort() { when(fireCloudService.isUserMemberOfGroup(any(), any())).thenReturn(true); UserResponse robinsonsAsc = userController.user("Robinson", null, null, "asc").getBody(); UserResponse robinsonsDesc = userController.user("Robinson", null, null, "desc").getBody(); assertThat(robinsonsAsc.getUsers()).containsAllIn(robinsonsDesc.getUsers()); List<User> descendingReversed = Lists.reverse(robinsonsDesc.getUsers()); assertThat(robinsonsAsc.getUsers()).containsAllIn(descendingReversed).inOrder(); List<User> newAscending = Lists.newArrayList(robinsonsAsc.getUsers()); newAscending.sort(Comparator.comparing(User::getUserName)); assertThat(robinsonsAsc.getUsers()).containsAllIn(newAscending).inOrder(); } | @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<UserResponse> user( String term, String pageToken, Integer size, String sortOrder) { UserResponse response = new UserResponse(); response.setUsers(Collections.emptyList()); response.setNextPageToken(""); if (null == term || term.isEmpty()) { return ResponseEntity.ok(response); } PaginationToken paginationToken; try { paginationToken = getPaginationTokenFromPageToken(pageToken); } catch (IllegalArgumentException | BadRequestException e) { return ResponseEntity.badRequest().body(response); } WorkbenchConfig config = configProvider.get(); if (!fireCloudService.isUserMemberOfGroup( userProvider.get().getUsername(), config.firecloud.registeredDomainName)) { throw new ForbiddenException("user search requires registered data access"); } Sort.Direction direction = Optional.ofNullable(Sort.Direction.fromStringOrNull(sortOrder)).orElse(Sort.Direction.ASC); Sort sort = new Sort(new Sort.Order(direction, DEFAULT_SORT_FIELD)); List<DbUser> users = userService.findUsersBySearchString(term, sort).stream() .filter(user -> user.getFirstSignInTime() != null) .collect(Collectors.toList()); int pageSize = Optional.ofNullable(size).orElse(DEFAULT_PAGE_SIZE); List<List<DbUser>> pagedUsers = Lists.partition(users, pageSize); int pageOffset = Long.valueOf(paginationToken.getOffset()).intValue(); if (pagedUsers.size() == 0) { return ResponseEntity.ok(response); } if (pageOffset < pagedUsers.size()) { boolean hasNext = pageOffset < pagedUsers.size() - 1; if (hasNext) { response.setNextPageToken(PaginationToken.of(pageOffset + 1).toBase64()); } List<org.pmiops.workbench.model.User> modelUsers = pagedUsers.get(pageOffset).stream() .map(TO_USER_RESPONSE_USER) .collect(Collectors.toList()); response.setUsers(modelUsers); } else { log.warning( String.format( "User attempted autocomplete for a paged result that doesn't exist. Term: %s. Page: %d", term, pageOffset)); return ResponseEntity.badRequest().body(response); } return ResponseEntity.ok(response); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void listBillingAccounts_upgradeYES_freeYES_cloudYES() throws IOException { config.billing = new BillingConfig(); config.billing.accountId = "free-tier"; config.featureFlags.enableBillingUpgrade = true; when(mockFreeTierBillingService.userHasRemainingFreeTierCredits(any())).thenReturn(true); when(testCloudbilling.billingAccounts().list().execute()) .thenReturn(new ListBillingAccountsResponse().setBillingAccounts(cloudbillingAccounts)); final List<BillingAccount> expectedWorkbenchBillingAccounts = ListUtils.union( Lists.newArrayList(freeTierBillingAccount), cloudbillingAccountsInWorkbench); final WorkbenchListBillingAccountsResponse response = userController.listBillingAccounts().getBody(); assertThat(response.getBillingAccounts()).isEqualTo(expectedWorkbenchBillingAccounts); } | @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void listBillingAccounts_upgradeYES_freeYES_cloudNO() throws IOException { config.billing = new BillingConfig(); config.billing.accountId = "free-tier"; config.featureFlags.enableBillingUpgrade = true; when(mockFreeTierBillingService.userHasRemainingFreeTierCredits(any())).thenReturn(true); when(testCloudbilling.billingAccounts().list().execute()) .thenReturn(new ListBillingAccountsResponse().setBillingAccounts(null)); final List<BillingAccount> expectedWorkbenchBillingAccounts = Lists.newArrayList(freeTierBillingAccount); final WorkbenchListBillingAccountsResponse response = userController.listBillingAccounts().getBody(); assertThat(response.getBillingAccounts()).isEqualTo(expectedWorkbenchBillingAccounts); } | @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void checkFreeTierBillingUsage_ignoreOLDMigrationStatus() { workbenchConfig.billing.defaultFreeCreditsDollarLimit = 100.0; doReturn(mockBQTableSingleResult(100.01)).when(bigQueryService).executeQuery(any()); final DbUser user = createUser(SINGLE_WORKSPACE_TEST_USER); createWorkspace(user, SINGLE_WORKSPACE_TEST_PROJECT, BillingMigrationStatus.OLD); freeTierBillingService.checkFreeTierBillingUsage(); verifyZeroInteractions(mailService); assertThat(workspaceFreeTierUsageDao.count()).isEqualTo(0); } | public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } |
@Test public void listBillingAccounts_upgradeYES_freeNO_cloudYES() throws IOException { config.billing = new BillingConfig(); config.billing.accountId = "free-tier"; config.featureFlags.enableBillingUpgrade = true; when(mockFreeTierBillingService.userHasRemainingFreeTierCredits(any())).thenReturn(false); when(testCloudbilling.billingAccounts().list().execute()) .thenReturn(new ListBillingAccountsResponse().setBillingAccounts(cloudbillingAccounts)); final List<BillingAccount> expectedWorkbenchBillingAccounts = cloudbillingAccountsInWorkbench; final WorkbenchListBillingAccountsResponse response = userController.listBillingAccounts().getBody(); assertThat(response.getBillingAccounts()).isEqualTo(expectedWorkbenchBillingAccounts); } | @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void listBillingAccounts_upgradeYES_freeNO_cloudNO() throws IOException { config.billing = new BillingConfig(); config.billing.accountId = "free-tier"; config.featureFlags.enableBillingUpgrade = true; when(mockFreeTierBillingService.userHasRemainingFreeTierCredits(any())).thenReturn(false); when(testCloudbilling.billingAccounts().list().execute()) .thenReturn(new ListBillingAccountsResponse().setBillingAccounts(null)); final WorkbenchListBillingAccountsResponse response = userController.listBillingAccounts().getBody(); assertThat(response.getBillingAccounts()).isEmpty(); } | @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void listBillingAccounts_upgradeNO_freeYES_cloudYES() throws IOException { config.billing = new BillingConfig(); config.billing.accountId = "free-tier"; config.featureFlags.enableBillingUpgrade = false; when(mockFreeTierBillingService.userHasRemainingFreeTierCredits(any())).thenReturn(true); when(testCloudbilling.billingAccounts().list().execute()) .thenReturn(new ListBillingAccountsResponse().setBillingAccounts(cloudbillingAccounts)); final List<BillingAccount> expectedWorkbenchBillingAccounts = Lists.newArrayList(freeTierBillingAccount); final WorkbenchListBillingAccountsResponse response = userController.listBillingAccounts().getBody(); assertThat(response.getBillingAccounts()).isEqualTo(expectedWorkbenchBillingAccounts); } | @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void listBillingAccounts_upgradeNO_freeYES_cloudNO() throws IOException { config.billing = new BillingConfig(); config.billing.accountId = "free-tier"; config.featureFlags.enableBillingUpgrade = false; when(mockFreeTierBillingService.userHasRemainingFreeTierCredits(any())).thenReturn(true); when(testCloudbilling.billingAccounts().list().execute()) .thenReturn(new ListBillingAccountsResponse().setBillingAccounts(null)); final List<BillingAccount> expectedWorkbenchBillingAccounts = Lists.newArrayList(freeTierBillingAccount); final WorkbenchListBillingAccountsResponse response = userController.listBillingAccounts().getBody(); assertThat(response.getBillingAccounts()).isEqualTo(expectedWorkbenchBillingAccounts); } | @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void listBillingAccounts_upgradeNO_freeNO_cloudYES() throws IOException { config.billing = new BillingConfig(); config.billing.accountId = "free-tier"; config.featureFlags.enableBillingUpgrade = false; when(mockFreeTierBillingService.userHasRemainingFreeTierCredits(any())).thenReturn(false); when(testCloudbilling.billingAccounts().list().execute()) .thenReturn(new ListBillingAccountsResponse().setBillingAccounts(cloudbillingAccounts)); final List<BillingAccount> expectedWorkbenchBillingAccounts = Lists.newArrayList(freeTierBillingAccount); final WorkbenchListBillingAccountsResponse response = userController.listBillingAccounts().getBody(); assertThat(response.getBillingAccounts()).isEqualTo(expectedWorkbenchBillingAccounts); } | @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void listBillingAccounts_upgradeNO_freeNO_cloudNO() throws IOException { config.billing = new BillingConfig(); config.billing.accountId = "free-tier"; config.featureFlags.enableBillingUpgrade = false; when(mockFreeTierBillingService.userHasRemainingFreeTierCredits(any())).thenReturn(false); when(testCloudbilling.billingAccounts().list().execute()) .thenReturn(new ListBillingAccountsResponse().setBillingAccounts(null)); final List<BillingAccount> expectedWorkbenchBillingAccounts = Lists.newArrayList(freeTierBillingAccount); final WorkbenchListBillingAccountsResponse response = userController.listBillingAccounts().getBody(); assertThat(response.getBillingAccounts()).isEqualTo(expectedWorkbenchBillingAccounts); } | @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } | UserController implements UserApiDelegate { @Override public ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts() { List<BillingAccount> billingAccounts = Stream.concat(maybeFreeTierBillingAccount(), maybeCloudBillingAccounts()) .collect(Collectors.toList()); return ResponseEntity.ok( new WorkbenchListBillingAccountsResponse().billingAccounts(billingAccounts)); } @Autowired UserController(
Provider<DbUser> userProvider,
Provider<WorkbenchConfig> configProvider,
FireCloudService fireCloudService,
UserService userService,
@Qualifier(END_USER_CLOUD_BILLING) Provider<Cloudbilling> cloudBillingProvider,
FreeTierBillingService freeTierBillingService); @Override ResponseEntity<UserResponse> user(
String term, String pageToken, Integer size, String sortOrder); @Override ResponseEntity<WorkbenchListBillingAccountsResponse> listBillingAccounts(); } |
@Test public void testGetProfile_empty() { assertThat(profileService.getProfile(userDao.save(new DbUser()))).isNotNull(); } | public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test public void testGetProfile_emptyDemographics() { DbUser user = new DbUser(); user.setDemographicSurvey(new DbDemographicSurvey()); user = userDao.save(user); assertThat(profileService.getProfile(user)).isNotNull(); } | public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test public void testReturnsLastAcknowledgedTermsOfService() { DbUserTermsOfService userTermsOfService = new DbUserTermsOfService(); userTermsOfService.setTosVersion(1); userTermsOfService.setAgreementTime(new Timestamp(1)); when(mockUserTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(1)) .thenReturn(Optional.of(userTermsOfService)); DbUser user = new DbUser(); user.setUserId(1); Profile profile = profileService.getProfile(user); assertThat(profile.getLatestTermsOfServiceVersion()).isEqualTo(1); assertThat(profile.getLatestTermsOfServiceTime()).isEqualTo(1); } | public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public Profile getProfile(DbUser userLite) { final DbUser user = userService.findUserWithAuthoritiesAndPageVisits(userLite.getUserId()).orElse(userLite); final @Nullable Double freeTierUsage = freeTierBillingService.getCachedFreeTierUsage(user); final @Nullable Double freeTierDollarQuota = freeTierBillingService.getUserFreeTierDollarLimit(user); final @Nullable VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(verifiedInstitutionalAffiliationMapper::dbToModel) .orElse(null); final @Nullable DbUserTermsOfService latestTermsOfService = userTermsOfServiceDao.findFirstByUserIdOrderByTosVersionDesc(user.getUserId()).orElse(null); return profileMapper.toModel( user, verifiedInstitutionalAffiliation, latestTermsOfService, freeTierUsage, freeTierDollarQuota); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test public void validateInstitutionalAffiliation() { Profile profile = new Profile() .verifiedInstitutionalAffiliation(BROAD_AFFILIATION) .contactEmail("[email protected]"); when(mockInstitutionDao.findOneByShortName("Broad")).thenReturn(Optional.of(BROAD_INSTITUTION)); DbVerifiedInstitutionalAffiliation dbVerifiedInstitutionalAffiliation = new DbVerifiedInstitutionalAffiliation(); dbVerifiedInstitutionalAffiliation.setInstitution(BROAD_INSTITUTION); dbVerifiedInstitutionalAffiliation.setInstitutionalRoleEnum(InstitutionalRole.ADMIN); when(mockVerifiedInstitutionalAffiliationMapper.modelToDbWithoutUser( BROAD_AFFILIATION, mockInstitutionService)) .thenReturn(dbVerifiedInstitutionalAffiliation); when(mockInstitutionService.validateAffiliation( dbVerifiedInstitutionalAffiliation, "[email protected]")) .thenReturn(true); profileService.validateAffiliation(profile); ArgumentCaptor<DbVerifiedInstitutionalAffiliation> affiliationSpy = ArgumentCaptor.forClass(DbVerifiedInstitutionalAffiliation.class); ArgumentCaptor<String> unusedSpy = ArgumentCaptor.forClass(String.class); verify(mockInstitutionService) .validateAffiliation(affiliationSpy.capture(), unusedSpy.capture()); assertThat(affiliationSpy.getValue().getInstitution().getShortName()).isEqualTo("Broad"); } | public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test public void checkFreeTierBillingUsage_ignoreMIGRATEDMigrationStatus() { workbenchConfig.billing.defaultFreeCreditsDollarLimit = 100.0; doReturn(mockBQTableSingleResult(100.01)).when(bigQueryService).executeQuery(any()); final DbUser user = createUser(SINGLE_WORKSPACE_TEST_USER); createWorkspace(user, SINGLE_WORKSPACE_TEST_PROJECT, BillingMigrationStatus.MIGRATED); freeTierBillingService.checkFreeTierBillingUsage(); verifyZeroInteractions(mailService); assertThat(workspaceFreeTierUsageDao.count()).isEqualTo(0); } | public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } |
@Test public void validateInstitutionalAffiliation_other() { VerifiedInstitutionalAffiliation affiliation = new VerifiedInstitutionalAffiliation() .institutionShortName("Broad") .institutionDisplayName("The Broad Institute") .institutionalRoleEnum(InstitutionalRole.OTHER) .institutionalRoleOtherText("Kibitzing"); Profile profile = new Profile() .verifiedInstitutionalAffiliation(affiliation) .contactEmail("[email protected]"); when(mockInstitutionDao.findOneByShortName("Broad")).thenReturn(Optional.of(BROAD_INSTITUTION)); DbVerifiedInstitutionalAffiliation dbVerifiedInstitutionalAffiliation = new DbVerifiedInstitutionalAffiliation(); dbVerifiedInstitutionalAffiliation.setInstitution(BROAD_INSTITUTION); dbVerifiedInstitutionalAffiliation.setInstitutionalRoleEnum(InstitutionalRole.ADMIN); when(mockVerifiedInstitutionalAffiliationMapper.modelToDbWithoutUser( affiliation, mockInstitutionService)) .thenReturn(dbVerifiedInstitutionalAffiliation); when(mockInstitutionService.validateAffiliation( dbVerifiedInstitutionalAffiliation, "[email protected]")) .thenReturn(true); profileService.validateAffiliation(profile); ArgumentCaptor<DbVerifiedInstitutionalAffiliation> affiliationSpy = ArgumentCaptor.forClass(DbVerifiedInstitutionalAffiliation.class); ArgumentCaptor<String> unusedSpy = ArgumentCaptor.forClass(String.class); verify(mockInstitutionService) .validateAffiliation(affiliationSpy.capture(), unusedSpy.capture()); assertThat(affiliationSpy.getValue().getInstitution().getShortName()).isEqualTo("Broad"); } | public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateInstitutionalAffiliation_noAffiliation() { profileService.validateAffiliation(new Profile()); } | public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = NotFoundException.class) public void validateInstitutionalAffiliation_noInstitution() { Profile profile = new Profile().verifiedInstitutionalAffiliation(BROAD_AFFILIATION); when(mockInstitutionDao.findOneByShortName("Broad")).thenReturn(Optional.empty()); profileService.validateAffiliation(profile); } | public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateInstitutionalAffiliation_noRole() { VerifiedInstitutionalAffiliation affiliation = new VerifiedInstitutionalAffiliation() .institutionShortName("Broad") .institutionDisplayName("The Broad Institute"); Profile profile = new Profile().verifiedInstitutionalAffiliation(affiliation); when(mockInstitutionDao.findOneByShortName("Broad")).thenReturn(Optional.of(BROAD_INSTITUTION)); profileService.validateAffiliation(profile); } | public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateInstitutionalAffiliation_noOtherText() { VerifiedInstitutionalAffiliation affiliation = new VerifiedInstitutionalAffiliation() .institutionShortName("Broad") .institutionDisplayName("The Broad Institute") .institutionalRoleEnum(InstitutionalRole.OTHER); Profile profile = new Profile().verifiedInstitutionalAffiliation(affiliation); when(mockInstitutionDao.findOneByShortName("Broad")).thenReturn(Optional.of(BROAD_INSTITUTION)); profileService.validateAffiliation(profile); } | public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateInstitutionalAffilation_badEmail() { VerifiedInstitutionalAffiliation affiliation = new VerifiedInstitutionalAffiliation() .institutionShortName("Broad") .institutionDisplayName("The Broad Institute") .institutionalRoleEnum(InstitutionalRole.OTHER) .institutionalRoleOtherText("Kibitzing"); Profile profile = new Profile() .verifiedInstitutionalAffiliation(affiliation) .contactEmail("[email protected]"); when(mockInstitutionDao.findOneByShortName("Broad")).thenReturn(Optional.of(BROAD_INSTITUTION)); when(mockInstitutionService.validateAffiliation( any(DbVerifiedInstitutionalAffiliation.class), anyString())) .thenReturn(false); DbVerifiedInstitutionalAffiliation dbVerifiedInstitutionalAffiliation = new DbVerifiedInstitutionalAffiliation(); dbVerifiedInstitutionalAffiliation.setInstitution(BROAD_INSTITUTION); when(mockVerifiedInstitutionalAffiliationMapper.modelToDbWithoutUser( affiliation, mockInstitutionService)) .thenReturn(dbVerifiedInstitutionalAffiliation); profileService.validateAffiliation(profile); } | public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public void validateAffiliation(Profile profile) { VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation = profile.getVerifiedInstitutionalAffiliation(); if (verifiedInstitutionalAffiliation == null) { throw new BadRequestException("Institutional affiliation cannot be empty"); } Optional<DbInstitution> institution = institutionDao.findOneByShortName( verifiedInstitutionalAffiliation.getInstitutionShortName()); if (!institution.isPresent()) { throw new NotFoundException( String.format( "Could not find institution %s in database", verifiedInstitutionalAffiliation.getInstitutionShortName())); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum() == null) { throw new BadRequestException("Institutional role cannot be empty"); } if (verifiedInstitutionalAffiliation.getInstitutionalRoleEnum().equals(InstitutionalRole.OTHER) && (verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText() == null || verifiedInstitutionalAffiliation.getInstitutionalRoleOtherText().equals(""))) { throw new BadRequestException( "Institutional role description cannot be empty when institutional role is set to Other"); } validateAffiliationEmail(profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void updateProfile_cant_change_contactEmail() { Profile previousProfile = createValidProfile().contactEmail("[email protected]"); Profile updatedProfile = createValidProfile().contactEmail("[email protected]"); DbUser user = new DbUser(); user.setUserId(10); user.setGivenName("John"); user.setFamilyName("Doe"); profileService.updateProfile(user, updatedProfile, previousProfile); } | public void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile) { cleanProfile(updatedProfile); cleanProfile(previousProfile); validateProfile(updatedProfile, previousProfile); if (!user.getGivenName().equalsIgnoreCase(updatedProfile.getGivenName()) || !user.getFamilyName().equalsIgnoreCase(updatedProfile.getFamilyName())) { userService.setDataUseAgreementNameOutOfDate( updatedProfile.getGivenName(), updatedProfile.getFamilyName()); } Timestamp now = new Timestamp(clock.instant().toEpochMilli()); user.setContactEmail(updatedProfile.getContactEmail()); user.setGivenName(updatedProfile.getGivenName()); user.setFamilyName(updatedProfile.getFamilyName()); user.setAreaOfResearch(updatedProfile.getAreaOfResearch()); user.setProfessionalUrl(updatedProfile.getProfessionalUrl()); user.setAddress(addressMapper.addressToDbAddress(updatedProfile.getAddress())); Optional.ofNullable(user.getAddress()).ifPresent(address -> address.setUser(user)); DbDemographicSurvey dbDemographicSurvey = demographicSurveyMapper.demographicSurveyToDbDemographicSurvey( updatedProfile.getDemographicSurvey()); if (user.getDemographicSurveyCompletionTime() == null && dbDemographicSurvey != null) { user.setDemographicSurveyCompletionTime(now); } if (dbDemographicSurvey != null && dbDemographicSurvey.getUser() == null) { dbDemographicSurvey.setUser(user); } user.setDemographicSurvey(dbDemographicSurvey); user.setLastModifiedTime(now); userService.updateUserWithConflictHandling(user); DbVerifiedInstitutionalAffiliation newAffiliation = verifiedInstitutionalAffiliationMapper.modelToDbWithoutUser( updatedProfile.getVerifiedInstitutionalAffiliation(), institutionService); newAffiliation.setUser( user); verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(DbVerifiedInstitutionalAffiliation::getVerifiedInstitutionalAffiliationId) .ifPresent(newAffiliation::setVerifiedInstitutionalAffiliationId); this.verifiedInstitutionalAffiliationDao.save(newAffiliation); final Profile appliedUpdatedProfile = getProfile(user); profileAuditor.fireUpdateAction(previousProfile, appliedUpdatedProfile); } | ProfileService { public void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile) { cleanProfile(updatedProfile); cleanProfile(previousProfile); validateProfile(updatedProfile, previousProfile); if (!user.getGivenName().equalsIgnoreCase(updatedProfile.getGivenName()) || !user.getFamilyName().equalsIgnoreCase(updatedProfile.getFamilyName())) { userService.setDataUseAgreementNameOutOfDate( updatedProfile.getGivenName(), updatedProfile.getFamilyName()); } Timestamp now = new Timestamp(clock.instant().toEpochMilli()); user.setContactEmail(updatedProfile.getContactEmail()); user.setGivenName(updatedProfile.getGivenName()); user.setFamilyName(updatedProfile.getFamilyName()); user.setAreaOfResearch(updatedProfile.getAreaOfResearch()); user.setProfessionalUrl(updatedProfile.getProfessionalUrl()); user.setAddress(addressMapper.addressToDbAddress(updatedProfile.getAddress())); Optional.ofNullable(user.getAddress()).ifPresent(address -> address.setUser(user)); DbDemographicSurvey dbDemographicSurvey = demographicSurveyMapper.demographicSurveyToDbDemographicSurvey( updatedProfile.getDemographicSurvey()); if (user.getDemographicSurveyCompletionTime() == null && dbDemographicSurvey != null) { user.setDemographicSurveyCompletionTime(now); } if (dbDemographicSurvey != null && dbDemographicSurvey.getUser() == null) { dbDemographicSurvey.setUser(user); } user.setDemographicSurvey(dbDemographicSurvey); user.setLastModifiedTime(now); userService.updateUserWithConflictHandling(user); DbVerifiedInstitutionalAffiliation newAffiliation = verifiedInstitutionalAffiliationMapper.modelToDbWithoutUser( updatedProfile.getVerifiedInstitutionalAffiliation(), institutionService); newAffiliation.setUser( user); verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(DbVerifiedInstitutionalAffiliation::getVerifiedInstitutionalAffiliationId) .ifPresent(newAffiliation::setVerifiedInstitutionalAffiliationId); this.verifiedInstitutionalAffiliationDao.save(newAffiliation); final Profile appliedUpdatedProfile = getProfile(user); profileAuditor.fireUpdateAction(previousProfile, appliedUpdatedProfile); } } | ProfileService { public void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile) { cleanProfile(updatedProfile); cleanProfile(previousProfile); validateProfile(updatedProfile, previousProfile); if (!user.getGivenName().equalsIgnoreCase(updatedProfile.getGivenName()) || !user.getFamilyName().equalsIgnoreCase(updatedProfile.getFamilyName())) { userService.setDataUseAgreementNameOutOfDate( updatedProfile.getGivenName(), updatedProfile.getFamilyName()); } Timestamp now = new Timestamp(clock.instant().toEpochMilli()); user.setContactEmail(updatedProfile.getContactEmail()); user.setGivenName(updatedProfile.getGivenName()); user.setFamilyName(updatedProfile.getFamilyName()); user.setAreaOfResearch(updatedProfile.getAreaOfResearch()); user.setProfessionalUrl(updatedProfile.getProfessionalUrl()); user.setAddress(addressMapper.addressToDbAddress(updatedProfile.getAddress())); Optional.ofNullable(user.getAddress()).ifPresent(address -> address.setUser(user)); DbDemographicSurvey dbDemographicSurvey = demographicSurveyMapper.demographicSurveyToDbDemographicSurvey( updatedProfile.getDemographicSurvey()); if (user.getDemographicSurveyCompletionTime() == null && dbDemographicSurvey != null) { user.setDemographicSurveyCompletionTime(now); } if (dbDemographicSurvey != null && dbDemographicSurvey.getUser() == null) { dbDemographicSurvey.setUser(user); } user.setDemographicSurvey(dbDemographicSurvey); user.setLastModifiedTime(now); userService.updateUserWithConflictHandling(user); DbVerifiedInstitutionalAffiliation newAffiliation = verifiedInstitutionalAffiliationMapper.modelToDbWithoutUser( updatedProfile.getVerifiedInstitutionalAffiliation(), institutionService); newAffiliation.setUser( user); verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(DbVerifiedInstitutionalAffiliation::getVerifiedInstitutionalAffiliationId) .ifPresent(newAffiliation::setVerifiedInstitutionalAffiliationId); this.verifiedInstitutionalAffiliationDao.save(newAffiliation); final Profile appliedUpdatedProfile = getProfile(user); profileAuditor.fireUpdateAction(previousProfile, appliedUpdatedProfile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile) { cleanProfile(updatedProfile); cleanProfile(previousProfile); validateProfile(updatedProfile, previousProfile); if (!user.getGivenName().equalsIgnoreCase(updatedProfile.getGivenName()) || !user.getFamilyName().equalsIgnoreCase(updatedProfile.getFamilyName())) { userService.setDataUseAgreementNameOutOfDate( updatedProfile.getGivenName(), updatedProfile.getFamilyName()); } Timestamp now = new Timestamp(clock.instant().toEpochMilli()); user.setContactEmail(updatedProfile.getContactEmail()); user.setGivenName(updatedProfile.getGivenName()); user.setFamilyName(updatedProfile.getFamilyName()); user.setAreaOfResearch(updatedProfile.getAreaOfResearch()); user.setProfessionalUrl(updatedProfile.getProfessionalUrl()); user.setAddress(addressMapper.addressToDbAddress(updatedProfile.getAddress())); Optional.ofNullable(user.getAddress()).ifPresent(address -> address.setUser(user)); DbDemographicSurvey dbDemographicSurvey = demographicSurveyMapper.demographicSurveyToDbDemographicSurvey( updatedProfile.getDemographicSurvey()); if (user.getDemographicSurveyCompletionTime() == null && dbDemographicSurvey != null) { user.setDemographicSurveyCompletionTime(now); } if (dbDemographicSurvey != null && dbDemographicSurvey.getUser() == null) { dbDemographicSurvey.setUser(user); } user.setDemographicSurvey(dbDemographicSurvey); user.setLastModifiedTime(now); userService.updateUserWithConflictHandling(user); DbVerifiedInstitutionalAffiliation newAffiliation = verifiedInstitutionalAffiliationMapper.modelToDbWithoutUser( updatedProfile.getVerifiedInstitutionalAffiliation(), institutionService); newAffiliation.setUser( user); verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(DbVerifiedInstitutionalAffiliation::getVerifiedInstitutionalAffiliationId) .ifPresent(newAffiliation::setVerifiedInstitutionalAffiliationId); this.verifiedInstitutionalAffiliationDao.save(newAffiliation); final Profile appliedUpdatedProfile = getProfile(user); profileAuditor.fireUpdateAction(previousProfile, appliedUpdatedProfile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile) { cleanProfile(updatedProfile); cleanProfile(previousProfile); validateProfile(updatedProfile, previousProfile); if (!user.getGivenName().equalsIgnoreCase(updatedProfile.getGivenName()) || !user.getFamilyName().equalsIgnoreCase(updatedProfile.getFamilyName())) { userService.setDataUseAgreementNameOutOfDate( updatedProfile.getGivenName(), updatedProfile.getFamilyName()); } Timestamp now = new Timestamp(clock.instant().toEpochMilli()); user.setContactEmail(updatedProfile.getContactEmail()); user.setGivenName(updatedProfile.getGivenName()); user.setFamilyName(updatedProfile.getFamilyName()); user.setAreaOfResearch(updatedProfile.getAreaOfResearch()); user.setProfessionalUrl(updatedProfile.getProfessionalUrl()); user.setAddress(addressMapper.addressToDbAddress(updatedProfile.getAddress())); Optional.ofNullable(user.getAddress()).ifPresent(address -> address.setUser(user)); DbDemographicSurvey dbDemographicSurvey = demographicSurveyMapper.demographicSurveyToDbDemographicSurvey( updatedProfile.getDemographicSurvey()); if (user.getDemographicSurveyCompletionTime() == null && dbDemographicSurvey != null) { user.setDemographicSurveyCompletionTime(now); } if (dbDemographicSurvey != null && dbDemographicSurvey.getUser() == null) { dbDemographicSurvey.setUser(user); } user.setDemographicSurvey(dbDemographicSurvey); user.setLastModifiedTime(now); userService.updateUserWithConflictHandling(user); DbVerifiedInstitutionalAffiliation newAffiliation = verifiedInstitutionalAffiliationMapper.modelToDbWithoutUser( updatedProfile.getVerifiedInstitutionalAffiliation(), institutionService); newAffiliation.setUser( user); verifiedInstitutionalAffiliationDao .findFirstByUser(user) .map(DbVerifiedInstitutionalAffiliation::getVerifiedInstitutionalAffiliationId) .ifPresent(newAffiliation::setVerifiedInstitutionalAffiliationId); this.verifiedInstitutionalAffiliationDao.save(newAffiliation); final Profile appliedUpdatedProfile = getProfile(user); profileAuditor.fireUpdateAction(previousProfile, appliedUpdatedProfile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test public void validateProfile_noChangesOnEmptyProfile() { profileService.validateProfile(new Profile(), new Profile()); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateProfile_emptyNewObject() { profileService.validateNewProfile(new Profile()); } | public void validateNewProfile(Profile profile) throws BadRequestException { final Profile dummyProfile = null; validateProfileForCorrectness(dummyProfile, profile); } | ProfileService { public void validateNewProfile(Profile profile) throws BadRequestException { final Profile dummyProfile = null; validateProfileForCorrectness(dummyProfile, profile); } } | ProfileService { public void validateNewProfile(Profile profile) throws BadRequestException { final Profile dummyProfile = null; validateProfileForCorrectness(dummyProfile, profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public void validateNewProfile(Profile profile) throws BadRequestException { final Profile dummyProfile = null; validateProfileForCorrectness(dummyProfile, profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public void validateNewProfile(Profile profile) throws BadRequestException { final Profile dummyProfile = null; validateProfileForCorrectness(dummyProfile, profile); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateProfile_usernameChanged_user() { profileService.validateProfile(new Profile().username("new"), new Profile().username("old")); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test public void checkFreeTierBillingUsage_dbUpdate() throws MessagingException { workbenchConfig.billing.defaultFreeCreditsDollarLimit = 100.0; doReturn(mockBQTableSingleResult(100.01)).when(bigQueryService).executeQuery(any()); final DbUser user = createUser(SINGLE_WORKSPACE_TEST_USER); final DbWorkspace workspace = createWorkspace(user, SINGLE_WORKSPACE_TEST_PROJECT); freeTierBillingService.checkFreeTierBillingUsage(); verify(mailService).alertUserFreeTierExpiration(eq(user)); assertSingleWorkspaceTestDbState(user, workspace, BillingStatus.INACTIVE, 100.01); Timestamp t0 = workspaceFreeTierUsageDao.findAll().iterator().next().getLastUpdateTime(); final double newTotalCost = 123.45; doReturn(mockBQTableSingleResult(newTotalCost)).when(bigQueryService).executeQuery(any()); freeTierBillingService.checkFreeTierBillingUsage(); verify(mailService, times(1)).alertUserFreeTierExpiration(eq(user)); DbWorkspace dbWorkspace = workspaceDao.findOne(workspace.getWorkspaceId()); assertThat(dbWorkspace.getBillingStatus()).isEqualTo(BillingStatus.INACTIVE); assertThat(dbWorkspace.getBillingAccountType()).isEqualTo(BillingAccountType.FREE_TIER); assertThat(workspaceFreeTierUsageDao.count()).isEqualTo(1); DbWorkspaceFreeTierUsage dbEntry = workspaceFreeTierUsageDao.findAll().iterator().next(); assertThat(dbEntry.getUser()).isEqualTo(user); assertThat(dbEntry.getWorkspace()).isEqualTo(workspace); assertWithinBillingTolerance(dbEntry.getCost(), newTotalCost); Timestamp t1 = dbEntry.getLastUpdateTime(); assertThat(t1.after(t0)).isTrue(); } | public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } | FreeTierBillingService { public void checkFreeTierBillingUsage() { final Map<DbUser, Double> previousUserCosts = workspaceFreeTierUsageDao.getUserCostMap(); final Map<DbWorkspace, Double> workspaceCosts = getFreeTierWorkspaceCostsFromBQ(); workspaceCosts.forEach(workspaceFreeTierUsageDao::updateCost); final Map<DbUser, Double> userCosts = workspaceCosts.entrySet().stream() .collect( Collectors.groupingBy( e -> e.getKey().getCreator(), Collectors.summingDouble(Entry::getValue))); final Set<DbUser> previouslyExpiredUsers = getExpiredUsersFromDb(); final Set<DbUser> expiredUsers = userCosts.entrySet().stream() .filter(e -> costAboveLimit(e.getKey(), e.getValue())) .map(Entry::getKey) .collect(Collectors.toSet()); final Set<DbUser> newlyExpiredUsers = Sets.difference(expiredUsers, previouslyExpiredUsers); for (final DbUser user : newlyExpiredUsers) { try { mailService.alertUserFreeTierExpiration(user); } catch (final MessagingException e) { logger.log(Level.WARNING, e.getMessage()); } updateFreeTierWorkspacesStatus(user, BillingStatus.INACTIVE); } final Set<DbUser> usersWithNonNullRegistration = userDao.findByFirstRegistrationCompletionTimeNotNull(); final Set<DbUser> usersToThresholdCheck = Sets.difference(usersWithNonNullRegistration, expiredUsers); sendAlertsForCostThresholds(usersToThresholdCheck, previousUserCosts, userCosts); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } |
@Test(expected = BadRequestException.class) public void validateProfile_usernameChanged_admin() { when(mockUserService.hasAuthority(loggedInUser.getUserId(), Authority.ACCESS_CONTROL_ADMIN)) .thenReturn(true); profileService.validateProfile(new Profile().username("new"), new Profile().username("old")); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateProfile_usernameTooShort() { profileService.validateProfile(new Profile().username("ab"), new Profile()); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateProfile_usernameTooLong() { profileService.validateProfile( new Profile().username(StringUtils.repeat("asdf", 30)), new Profile()); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateProfile_contactEmailChanged_user() { profileService.validateProfile( new Profile().contactEmail("[email protected]"), new Profile().contactEmail("[email protected]")); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test public void validateProfile_contactEmailChanged_admin() { when(mockUserService.hasAuthority(loggedInUser.getUserId(), Authority.ACCESS_CONTROL_ADMIN)) .thenReturn(true); profileService.validateProfile( new Profile().contactEmail("[email protected]"), new Profile().contactEmail("[email protected]")); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateProfile_givenNameTooShort() { Profile newProfile = new Profile().givenName(""); profileService.validateProfile(newProfile, new Profile()); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateProfile_FamilyNameTooLong() { Profile newProfile = new Profile().familyName(StringUtils.repeat("123", 30)); profileService.validateProfile(newProfile, new Profile()); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateProfile_addressRemoved() { Profile oldProfile = new Profile().address(new Address().streetAddress1("asdf")); Profile newProfile = new Profile(); profileService.validateProfile(newProfile, oldProfile); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateProfile_addressRemoveZipCode() { Address oldAddress = new Address() .streetAddress1("asdf") .city("asdf") .state("asdf") .country("asdf") .zipCode("asdf"); Address newAddress = new Address().streetAddress1("asdf").city("asdf").state("asdf").country("asdf"); profileService.validateProfile( new Profile().address(newAddress), new Profile().address(oldAddress)); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test(expected = BadRequestException.class) public void validateProfile_addressIncomplete() { Profile newProfile = new Profile().address(new Address().streetAddress1("asdf")); profileService.validateProfile(newProfile, new Profile()); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test public void getUserFreeTierDollarLimit_default() { final DbUser user = createUser(SINGLE_WORKSPACE_TEST_USER); final double initialFreeCreditsDollarLimit = 1.0; workbenchConfig.billing.defaultFreeCreditsDollarLimit = initialFreeCreditsDollarLimit; assertWithinBillingTolerance( freeTierBillingService.getUserFreeTierDollarLimit(user), initialFreeCreditsDollarLimit); final double fractionalFreeCreditsDollarLimit = 123.456; workbenchConfig.billing.defaultFreeCreditsDollarLimit = fractionalFreeCreditsDollarLimit; assertWithinBillingTolerance( freeTierBillingService.getUserFreeTierDollarLimit(user), fractionalFreeCreditsDollarLimit); } | public double getUserFreeTierDollarLimit(DbUser user) { return Optional.ofNullable(user.getFreeTierCreditsLimitDollarsOverride()) .orElse(workbenchConfigProvider.get().billing.defaultFreeCreditsDollarLimit); } | FreeTierBillingService { public double getUserFreeTierDollarLimit(DbUser user) { return Optional.ofNullable(user.getFreeTierCreditsLimitDollarsOverride()) .orElse(workbenchConfigProvider.get().billing.defaultFreeCreditsDollarLimit); } } | FreeTierBillingService { public double getUserFreeTierDollarLimit(DbUser user) { return Optional.ofNullable(user.getFreeTierCreditsLimitDollarsOverride()) .orElse(workbenchConfigProvider.get().billing.defaultFreeCreditsDollarLimit); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); } | FreeTierBillingService { public double getUserFreeTierDollarLimit(DbUser user) { return Optional.ofNullable(user.getFreeTierCreditsLimitDollarsOverride()) .orElse(workbenchConfigProvider.get().billing.defaultFreeCreditsDollarLimit); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } | FreeTierBillingService { public double getUserFreeTierDollarLimit(DbUser user) { return Optional.ofNullable(user.getFreeTierCreditsLimitDollarsOverride()) .orElse(workbenchConfigProvider.get().billing.defaultFreeCreditsDollarLimit); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } |
@Test(expected = BadRequestException.class) public void validateProfile_EmptyAreaOfResearch() { Profile newProfile = new Profile().areaOfResearch(""); profileService.validateProfile(newProfile, new Profile()); } | @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { @VisibleForTesting public void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile) { final Diff diff = javers.compare(previousProfile, updatedProfile); validateProfileForCorrectness(diff, updatedProfile); if (userService.hasAuthority(userProvider.get().getUserId(), Authority.ACCESS_CONTROL_ADMIN)) { validateChangesAllowedByAdmin(diff); } else { validateChangesAllowedByUser(diff); } } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test public void testListAllProfiles_noUsers() { final List<Profile> profiles = profileService.listAllProfiles(); assertThat(profiles).isEmpty(); } | public List<Profile> listAllProfiles() { final Set<DbUser> usersHeavy = userService.findAllUsersWithAuthoritiesAndPageVisits(); final Map<Long, VerifiedInstitutionalAffiliation> userIdToAffiliationModel = StreamSupport.stream(verifiedInstitutionalAffiliationDao.findAll().spliterator(), false) .collect( ImmutableMap.toImmutableMap( (DbVerifiedInstitutionalAffiliation a) -> a.getUser().getUserId(), verifiedInstitutionalAffiliationMapper::dbToModel)); final Multimap<Long, DbUserTermsOfService> userIdToTosRecords = Multimaps.index(userTermsOfServiceDao.findAll(), DbUserTermsOfService::getUserId); final Map<Long, DbUserTermsOfService> userIdToMostRecentTos = userIdToTosRecords.asMap().entrySet().stream() .collect( ImmutableMap.toImmutableMap( Entry::getKey, e -> e.getValue().stream() .max(Comparator.comparing(DbUserTermsOfService::getAgreementTime)) .orElse( null))); final Map<Long, Double> userIdToFreeTierUsage = freeTierBillingService.getUserIdToTotalCost(); final Map<Long, Double> userIdToQuota = usersHeavy.stream() .collect( ImmutableMap.toImmutableMap( DbUser::getUserId, freeTierBillingService::getUserFreeTierDollarLimit)); return usersHeavy.stream() .map( dbUser -> profileMapper.toModel( dbUser, userIdToAffiliationModel.get(dbUser.getUserId()), userIdToMostRecentTos.get(dbUser.getUserId()), userIdToFreeTierUsage.get(dbUser.getUserId()), userIdToQuota.get(dbUser.getUserId()))) .collect(ImmutableList.toImmutableList()); } | ProfileService { public List<Profile> listAllProfiles() { final Set<DbUser> usersHeavy = userService.findAllUsersWithAuthoritiesAndPageVisits(); final Map<Long, VerifiedInstitutionalAffiliation> userIdToAffiliationModel = StreamSupport.stream(verifiedInstitutionalAffiliationDao.findAll().spliterator(), false) .collect( ImmutableMap.toImmutableMap( (DbVerifiedInstitutionalAffiliation a) -> a.getUser().getUserId(), verifiedInstitutionalAffiliationMapper::dbToModel)); final Multimap<Long, DbUserTermsOfService> userIdToTosRecords = Multimaps.index(userTermsOfServiceDao.findAll(), DbUserTermsOfService::getUserId); final Map<Long, DbUserTermsOfService> userIdToMostRecentTos = userIdToTosRecords.asMap().entrySet().stream() .collect( ImmutableMap.toImmutableMap( Entry::getKey, e -> e.getValue().stream() .max(Comparator.comparing(DbUserTermsOfService::getAgreementTime)) .orElse( null))); final Map<Long, Double> userIdToFreeTierUsage = freeTierBillingService.getUserIdToTotalCost(); final Map<Long, Double> userIdToQuota = usersHeavy.stream() .collect( ImmutableMap.toImmutableMap( DbUser::getUserId, freeTierBillingService::getUserFreeTierDollarLimit)); return usersHeavy.stream() .map( dbUser -> profileMapper.toModel( dbUser, userIdToAffiliationModel.get(dbUser.getUserId()), userIdToMostRecentTos.get(dbUser.getUserId()), userIdToFreeTierUsage.get(dbUser.getUserId()), userIdToQuota.get(dbUser.getUserId()))) .collect(ImmutableList.toImmutableList()); } } | ProfileService { public List<Profile> listAllProfiles() { final Set<DbUser> usersHeavy = userService.findAllUsersWithAuthoritiesAndPageVisits(); final Map<Long, VerifiedInstitutionalAffiliation> userIdToAffiliationModel = StreamSupport.stream(verifiedInstitutionalAffiliationDao.findAll().spliterator(), false) .collect( ImmutableMap.toImmutableMap( (DbVerifiedInstitutionalAffiliation a) -> a.getUser().getUserId(), verifiedInstitutionalAffiliationMapper::dbToModel)); final Multimap<Long, DbUserTermsOfService> userIdToTosRecords = Multimaps.index(userTermsOfServiceDao.findAll(), DbUserTermsOfService::getUserId); final Map<Long, DbUserTermsOfService> userIdToMostRecentTos = userIdToTosRecords.asMap().entrySet().stream() .collect( ImmutableMap.toImmutableMap( Entry::getKey, e -> e.getValue().stream() .max(Comparator.comparing(DbUserTermsOfService::getAgreementTime)) .orElse( null))); final Map<Long, Double> userIdToFreeTierUsage = freeTierBillingService.getUserIdToTotalCost(); final Map<Long, Double> userIdToQuota = usersHeavy.stream() .collect( ImmutableMap.toImmutableMap( DbUser::getUserId, freeTierBillingService::getUserFreeTierDollarLimit)); return usersHeavy.stream() .map( dbUser -> profileMapper.toModel( dbUser, userIdToAffiliationModel.get(dbUser.getUserId()), userIdToMostRecentTos.get(dbUser.getUserId()), userIdToFreeTierUsage.get(dbUser.getUserId()), userIdToQuota.get(dbUser.getUserId()))) .collect(ImmutableList.toImmutableList()); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public List<Profile> listAllProfiles() { final Set<DbUser> usersHeavy = userService.findAllUsersWithAuthoritiesAndPageVisits(); final Map<Long, VerifiedInstitutionalAffiliation> userIdToAffiliationModel = StreamSupport.stream(verifiedInstitutionalAffiliationDao.findAll().spliterator(), false) .collect( ImmutableMap.toImmutableMap( (DbVerifiedInstitutionalAffiliation a) -> a.getUser().getUserId(), verifiedInstitutionalAffiliationMapper::dbToModel)); final Multimap<Long, DbUserTermsOfService> userIdToTosRecords = Multimaps.index(userTermsOfServiceDao.findAll(), DbUserTermsOfService::getUserId); final Map<Long, DbUserTermsOfService> userIdToMostRecentTos = userIdToTosRecords.asMap().entrySet().stream() .collect( ImmutableMap.toImmutableMap( Entry::getKey, e -> e.getValue().stream() .max(Comparator.comparing(DbUserTermsOfService::getAgreementTime)) .orElse( null))); final Map<Long, Double> userIdToFreeTierUsage = freeTierBillingService.getUserIdToTotalCost(); final Map<Long, Double> userIdToQuota = usersHeavy.stream() .collect( ImmutableMap.toImmutableMap( DbUser::getUserId, freeTierBillingService::getUserFreeTierDollarLimit)); return usersHeavy.stream() .map( dbUser -> profileMapper.toModel( dbUser, userIdToAffiliationModel.get(dbUser.getUserId()), userIdToMostRecentTos.get(dbUser.getUserId()), userIdToFreeTierUsage.get(dbUser.getUserId()), userIdToQuota.get(dbUser.getUserId()))) .collect(ImmutableList.toImmutableList()); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public List<Profile> listAllProfiles() { final Set<DbUser> usersHeavy = userService.findAllUsersWithAuthoritiesAndPageVisits(); final Map<Long, VerifiedInstitutionalAffiliation> userIdToAffiliationModel = StreamSupport.stream(verifiedInstitutionalAffiliationDao.findAll().spliterator(), false) .collect( ImmutableMap.toImmutableMap( (DbVerifiedInstitutionalAffiliation a) -> a.getUser().getUserId(), verifiedInstitutionalAffiliationMapper::dbToModel)); final Multimap<Long, DbUserTermsOfService> userIdToTosRecords = Multimaps.index(userTermsOfServiceDao.findAll(), DbUserTermsOfService::getUserId); final Map<Long, DbUserTermsOfService> userIdToMostRecentTos = userIdToTosRecords.asMap().entrySet().stream() .collect( ImmutableMap.toImmutableMap( Entry::getKey, e -> e.getValue().stream() .max(Comparator.comparing(DbUserTermsOfService::getAgreementTime)) .orElse( null))); final Map<Long, Double> userIdToFreeTierUsage = freeTierBillingService.getUserIdToTotalCost(); final Map<Long, Double> userIdToQuota = usersHeavy.stream() .collect( ImmutableMap.toImmutableMap( DbUser::getUserId, freeTierBillingService::getUserFreeTierDollarLimit)); return usersHeavy.stream() .map( dbUser -> profileMapper.toModel( dbUser, userIdToAffiliationModel.get(dbUser.getUserId()), userIdToMostRecentTos.get(dbUser.getUserId()), userIdToFreeTierUsage.get(dbUser.getUserId()), userIdToQuota.get(dbUser.getUserId()))) .collect(ImmutableList.toImmutableList()); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test public void testListAllProfiles_someUsers() { final DbUser user1 = new DbUser(); user1.setUserId(101L); user1.setUsername("[email protected]"); user1.setDisabled(false); user1.setAboutYou("Just a test user"); final DbUser user2 = new DbUser(); user2.setUserId(102l); user2.setUsername("[email protected]"); user2.setDisabled(true); user2.setAboutYou("a disabled user account"); final DbUser user3 = new DbUser(); user3.setUserId(103l); user3.setUsername("[email protected]"); user3.setDisabled(true); user3.setAboutYou("where to begin..."); doReturn(ImmutableSet.of(user1, user2, user3)) .when(mockUserService) .findAllUsersWithAuthoritiesAndPageVisits(); doReturn( ImmutableMap.of( user1.getUserId(), 1.75, user2.getUserId(), 67.53, user3.getUserId(), 0.00)) .when(mockFreeTierBillingService) .getUserIdToTotalCost(); doReturn(100.00).when(mockFreeTierBillingService).getUserFreeTierDollarLimit(user1); doReturn(200.00).when(mockFreeTierBillingService).getUserFreeTierDollarLimit(user2); doReturn(50.00).when(mockFreeTierBillingService).getUserFreeTierDollarLimit(user3); final DbUserTermsOfService dbTos1 = new DbUserTermsOfService(); dbTos1.setUserTermsOfServiceId(1L); dbTos1.setUserId(user1.getUserId()); dbTos1.setTosVersion(1); dbTos1.setAgreementTime(Timestamp.from(CLOCK.instant())); final DbUserTermsOfService dbTos2 = new DbUserTermsOfService(); dbTos2.setUserTermsOfServiceId(2L); dbTos2.setUserId(user2.getUserId()); dbTos2.setTosVersion(2); dbTos2.setAgreementTime(Timestamp.from(CLOCK.instant().plusSeconds(3600L))); final DbUserTermsOfService dbTos3 = new DbUserTermsOfService(); dbTos3.setUserTermsOfServiceId(3L); dbTos3.setUserId(user2.getUserId()); dbTos3.setTosVersion(2); final Timestamp tos3time = Timestamp.from(CLOCK.instant().plus(Duration.ofDays(30))); dbTos3.setAgreementTime(tos3time); doReturn(ImmutableList.of(dbTos1, dbTos2, dbTos3)).when(mockUserTermsOfServiceDao).findAll(); final DbInstitution dbInstitution1 = new DbInstitution(); dbInstitution1.setShortName("caltech"); dbInstitution1.setDisplayName("California Institute of Technology"); dbInstitution1.setOrganizationTypeEnum(OrganizationType.ACADEMIC_RESEARCH_INSTITUTION); dbInstitution1.setDuaTypeEnum(DuaType.MASTER); dbInstitution1.setInstitutionId(1L); final DbVerifiedInstitutionalAffiliation dbAffiliation1 = new DbVerifiedInstitutionalAffiliation(); dbAffiliation1.setVerifiedInstitutionalAffiliationId(1L); dbAffiliation1.setUser(user1); dbAffiliation1.setInstitution(dbInstitution1); doReturn(ImmutableList.of(dbAffiliation1)) .when(mockVerifiedInstitutionalAffiliationDao) .findAll(); final VerifiedInstitutionalAffiliation verifiedInstitutionalAffiliation1 = new VerifiedInstitutionalAffiliation() .institutionShortName(dbInstitution1.getShortName()) .institutionDisplayName(dbInstitution1.getDisplayName()) .institutionalRoleOtherText(dbInstitution1.getOrganizationTypeOtherText()); doReturn(verifiedInstitutionalAffiliation1) .when(mockVerifiedInstitutionalAffiliationMapper) .dbToModel(dbAffiliation1); final List<Profile> profiles = profileService.listAllProfiles(); assertThat(profiles).hasSize(3); assertThat(profiles.get(0).getVerifiedInstitutionalAffiliation().getInstitutionDisplayName()) .isEqualTo(dbInstitution1.getDisplayName()); assertThat(profiles.get(1).getUserId()).isEqualTo(user2.getUserId()); assertThat(profiles.get(1).getFreeTierDollarQuota()).isWithin(0.02).of(200.00); assertThat((double) profiles.get(1).getLatestTermsOfServiceTime()) .isWithin(500.0) .of(tos3time.getTime()); assertThat(profiles.get(2).getVerifiedInstitutionalAffiliation()).isNull(); assertThat(profiles.get(2).getFreeTierUsage()).isWithin(0.02).of(0.00); } | public List<Profile> listAllProfiles() { final Set<DbUser> usersHeavy = userService.findAllUsersWithAuthoritiesAndPageVisits(); final Map<Long, VerifiedInstitutionalAffiliation> userIdToAffiliationModel = StreamSupport.stream(verifiedInstitutionalAffiliationDao.findAll().spliterator(), false) .collect( ImmutableMap.toImmutableMap( (DbVerifiedInstitutionalAffiliation a) -> a.getUser().getUserId(), verifiedInstitutionalAffiliationMapper::dbToModel)); final Multimap<Long, DbUserTermsOfService> userIdToTosRecords = Multimaps.index(userTermsOfServiceDao.findAll(), DbUserTermsOfService::getUserId); final Map<Long, DbUserTermsOfService> userIdToMostRecentTos = userIdToTosRecords.asMap().entrySet().stream() .collect( ImmutableMap.toImmutableMap( Entry::getKey, e -> e.getValue().stream() .max(Comparator.comparing(DbUserTermsOfService::getAgreementTime)) .orElse( null))); final Map<Long, Double> userIdToFreeTierUsage = freeTierBillingService.getUserIdToTotalCost(); final Map<Long, Double> userIdToQuota = usersHeavy.stream() .collect( ImmutableMap.toImmutableMap( DbUser::getUserId, freeTierBillingService::getUserFreeTierDollarLimit)); return usersHeavy.stream() .map( dbUser -> profileMapper.toModel( dbUser, userIdToAffiliationModel.get(dbUser.getUserId()), userIdToMostRecentTos.get(dbUser.getUserId()), userIdToFreeTierUsage.get(dbUser.getUserId()), userIdToQuota.get(dbUser.getUserId()))) .collect(ImmutableList.toImmutableList()); } | ProfileService { public List<Profile> listAllProfiles() { final Set<DbUser> usersHeavy = userService.findAllUsersWithAuthoritiesAndPageVisits(); final Map<Long, VerifiedInstitutionalAffiliation> userIdToAffiliationModel = StreamSupport.stream(verifiedInstitutionalAffiliationDao.findAll().spliterator(), false) .collect( ImmutableMap.toImmutableMap( (DbVerifiedInstitutionalAffiliation a) -> a.getUser().getUserId(), verifiedInstitutionalAffiliationMapper::dbToModel)); final Multimap<Long, DbUserTermsOfService> userIdToTosRecords = Multimaps.index(userTermsOfServiceDao.findAll(), DbUserTermsOfService::getUserId); final Map<Long, DbUserTermsOfService> userIdToMostRecentTos = userIdToTosRecords.asMap().entrySet().stream() .collect( ImmutableMap.toImmutableMap( Entry::getKey, e -> e.getValue().stream() .max(Comparator.comparing(DbUserTermsOfService::getAgreementTime)) .orElse( null))); final Map<Long, Double> userIdToFreeTierUsage = freeTierBillingService.getUserIdToTotalCost(); final Map<Long, Double> userIdToQuota = usersHeavy.stream() .collect( ImmutableMap.toImmutableMap( DbUser::getUserId, freeTierBillingService::getUserFreeTierDollarLimit)); return usersHeavy.stream() .map( dbUser -> profileMapper.toModel( dbUser, userIdToAffiliationModel.get(dbUser.getUserId()), userIdToMostRecentTos.get(dbUser.getUserId()), userIdToFreeTierUsage.get(dbUser.getUserId()), userIdToQuota.get(dbUser.getUserId()))) .collect(ImmutableList.toImmutableList()); } } | ProfileService { public List<Profile> listAllProfiles() { final Set<DbUser> usersHeavy = userService.findAllUsersWithAuthoritiesAndPageVisits(); final Map<Long, VerifiedInstitutionalAffiliation> userIdToAffiliationModel = StreamSupport.stream(verifiedInstitutionalAffiliationDao.findAll().spliterator(), false) .collect( ImmutableMap.toImmutableMap( (DbVerifiedInstitutionalAffiliation a) -> a.getUser().getUserId(), verifiedInstitutionalAffiliationMapper::dbToModel)); final Multimap<Long, DbUserTermsOfService> userIdToTosRecords = Multimaps.index(userTermsOfServiceDao.findAll(), DbUserTermsOfService::getUserId); final Map<Long, DbUserTermsOfService> userIdToMostRecentTos = userIdToTosRecords.asMap().entrySet().stream() .collect( ImmutableMap.toImmutableMap( Entry::getKey, e -> e.getValue().stream() .max(Comparator.comparing(DbUserTermsOfService::getAgreementTime)) .orElse( null))); final Map<Long, Double> userIdToFreeTierUsage = freeTierBillingService.getUserIdToTotalCost(); final Map<Long, Double> userIdToQuota = usersHeavy.stream() .collect( ImmutableMap.toImmutableMap( DbUser::getUserId, freeTierBillingService::getUserFreeTierDollarLimit)); return usersHeavy.stream() .map( dbUser -> profileMapper.toModel( dbUser, userIdToAffiliationModel.get(dbUser.getUserId()), userIdToMostRecentTos.get(dbUser.getUserId()), userIdToFreeTierUsage.get(dbUser.getUserId()), userIdToQuota.get(dbUser.getUserId()))) .collect(ImmutableList.toImmutableList()); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); } | ProfileService { public List<Profile> listAllProfiles() { final Set<DbUser> usersHeavy = userService.findAllUsersWithAuthoritiesAndPageVisits(); final Map<Long, VerifiedInstitutionalAffiliation> userIdToAffiliationModel = StreamSupport.stream(verifiedInstitutionalAffiliationDao.findAll().spliterator(), false) .collect( ImmutableMap.toImmutableMap( (DbVerifiedInstitutionalAffiliation a) -> a.getUser().getUserId(), verifiedInstitutionalAffiliationMapper::dbToModel)); final Multimap<Long, DbUserTermsOfService> userIdToTosRecords = Multimaps.index(userTermsOfServiceDao.findAll(), DbUserTermsOfService::getUserId); final Map<Long, DbUserTermsOfService> userIdToMostRecentTos = userIdToTosRecords.asMap().entrySet().stream() .collect( ImmutableMap.toImmutableMap( Entry::getKey, e -> e.getValue().stream() .max(Comparator.comparing(DbUserTermsOfService::getAgreementTime)) .orElse( null))); final Map<Long, Double> userIdToFreeTierUsage = freeTierBillingService.getUserIdToTotalCost(); final Map<Long, Double> userIdToQuota = usersHeavy.stream() .collect( ImmutableMap.toImmutableMap( DbUser::getUserId, freeTierBillingService::getUserFreeTierDollarLimit)); return usersHeavy.stream() .map( dbUser -> profileMapper.toModel( dbUser, userIdToAffiliationModel.get(dbUser.getUserId()), userIdToMostRecentTos.get(dbUser.getUserId()), userIdToFreeTierUsage.get(dbUser.getUserId()), userIdToQuota.get(dbUser.getUserId()))) .collect(ImmutableList.toImmutableList()); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } | ProfileService { public List<Profile> listAllProfiles() { final Set<DbUser> usersHeavy = userService.findAllUsersWithAuthoritiesAndPageVisits(); final Map<Long, VerifiedInstitutionalAffiliation> userIdToAffiliationModel = StreamSupport.stream(verifiedInstitutionalAffiliationDao.findAll().spliterator(), false) .collect( ImmutableMap.toImmutableMap( (DbVerifiedInstitutionalAffiliation a) -> a.getUser().getUserId(), verifiedInstitutionalAffiliationMapper::dbToModel)); final Multimap<Long, DbUserTermsOfService> userIdToTosRecords = Multimaps.index(userTermsOfServiceDao.findAll(), DbUserTermsOfService::getUserId); final Map<Long, DbUserTermsOfService> userIdToMostRecentTos = userIdToTosRecords.asMap().entrySet().stream() .collect( ImmutableMap.toImmutableMap( Entry::getKey, e -> e.getValue().stream() .max(Comparator.comparing(DbUserTermsOfService::getAgreementTime)) .orElse( null))); final Map<Long, Double> userIdToFreeTierUsage = freeTierBillingService.getUserIdToTotalCost(); final Map<Long, Double> userIdToQuota = usersHeavy.stream() .collect( ImmutableMap.toImmutableMap( DbUser::getUserId, freeTierBillingService::getUserFreeTierDollarLimit)); return usersHeavy.stream() .map( dbUser -> profileMapper.toModel( dbUser, userIdToAffiliationModel.get(dbUser.getUserId()), userIdToMostRecentTos.get(dbUser.getUserId()), userIdToFreeTierUsage.get(dbUser.getUserId()), userIdToQuota.get(dbUser.getUserId()))) .collect(ImmutableList.toImmutableList()); } @Autowired ProfileService(
AddressMapper addressMapper,
Clock clock,
DemographicSurveyMapper demographicSurveyMapper,
FreeTierBillingService freeTierBillingService,
InstitutionDao institutionDao,
InstitutionService institutionService,
Javers javers,
ProfileAuditor profileAuditor,
ProfileMapper profileMapper,
Provider<DbUser> userProvider,
UserDao userDao,
UserService userService,
UserTermsOfServiceDao userTermsOfServiceDao,
VerifiedInstitutionalAffiliationDao verifiedInstitutionalAffiliationDao,
VerifiedInstitutionalAffiliationMapper verifiedInstitutionalAffiliationMapper); Profile getProfile(DbUser userLite); void validateAffiliation(Profile profile); void updateProfile(DbUser user, Profile updatedProfile, Profile previousProfile); void cleanProfile(Profile profile); @VisibleForTesting void validateProfile(@Nonnull Profile updatedProfile, @Nullable Profile previousProfile); void validateNewProfile(Profile profile); List<Profile> listAllProfiles(); Profile updateAccountProperties(AccountPropertyUpdate request); } |
@Test public void itMatchesGroup() { final Optional<String> nextLetter = Matchers.getGroup(SINGLE_GROUP_PATTERN, "abcdf", GROUP_NAME); assertThat(nextLetter).hasValue("f"); } | public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } |
@Test public void getGroup_noMatch() { final Optional<String> nextLetter = Matchers.getGroup(SINGLE_GROUP_PATTERN, "abcdk", GROUP_NAME); assertThat(nextLetter).isEmpty(); } | public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } |
@Test public void testGetGroup_noSuchGroup() { final Optional<String> nextLetter = Matchers.getGroup(SINGLE_GROUP_PATTERN, "abcdk", "oops"); assertThat(nextLetter).isEmpty(); } | public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } |
@Test public void testGetGroup_hyphens() { final Pattern VM_NAME_PATTERN = Pattern.compile("all-of-us-(?<userid>\\d+)-m"); final Optional<String> suffix = Matchers.getGroup(VM_NAME_PATTERN, "all-of-us-2222-m", "userid"); assertThat(suffix).hasValue("2222"); } | public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } | Matchers { public static Optional<String> getGroup(Matcher matcher, String groupName) { if (matcher.find()) { return Optional.ofNullable(matcher.group(groupName)); } else { return Optional.empty(); } } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } |
@Test public void testReplaceAll() { final String input = "food is good for you! 2food3."; final Map<Pattern, String> patternToReplacement = ImmutableMap.of( Pattern.compile("\\bfood\\b"), "exercise", Pattern.compile("\\s+"), "_", Pattern.compile("\\dfood\\d\\."), "<3"); final String updated = Matchers.replaceAllInMap(patternToReplacement, input); assertThat(updated).contains("exercise_is_good_for_you!_<3"); } | public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } |
@Test public void testReplaceAll_parameters() { final String input = "AND @after <= TIMESTAMP_MILLIS(CAST(jsonPayload.timestamp AS INT64))"; final Map<Pattern, String> patternToReplacement = ImmutableMap.of( Pattern.compile("(?<=\\W)@after\\b"), "TIMESTAMP 'WHENEVER'", Pattern.compile("\\bAS\\b"), "AS IF"); final String updated = Matchers.replaceAllInMap(patternToReplacement, input); assertThat(updated) .isEqualTo( "AND TIMESTAMP 'WHENEVER' <= TIMESTAMP_MILLIS(CAST(jsonPayload.timestamp AS IF INT64))"); } | public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } |
@Test public void testReplaceAll_multipleOccurrences() { final String input = "And she'll have fun fun fun til her daddy takes the T-bird away."; final Map<Pattern, String> patternToReplacement = ImmutableMap.of(Pattern.compile("\\bfun\\b"), "cat"); final String updated = Matchers.replaceAllInMap(patternToReplacement, input); assertThat(updated).contains("have cat cat cat"); } | public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } |
@Test public void userHasRemainingFreeTierCredits_newUser() { workbenchConfig.billing.defaultFreeCreditsDollarLimit = 100.0; final DbUser user1 = createUser(SINGLE_WORKSPACE_TEST_USER); assertThat(freeTierBillingService.userHasRemainingFreeTierCredits(user1)).isTrue(); } | public boolean userHasRemainingFreeTierCredits(DbUser user) { final double usage = Optional.ofNullable(getCachedFreeTierUsage(user)).orElse(0.0); return !costAboveLimit(user, usage); } | FreeTierBillingService { public boolean userHasRemainingFreeTierCredits(DbUser user) { final double usage = Optional.ofNullable(getCachedFreeTierUsage(user)).orElse(0.0); return !costAboveLimit(user, usage); } } | FreeTierBillingService { public boolean userHasRemainingFreeTierCredits(DbUser user) { final double usage = Optional.ofNullable(getCachedFreeTierUsage(user)).orElse(0.0); return !costAboveLimit(user, usage); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); } | FreeTierBillingService { public boolean userHasRemainingFreeTierCredits(DbUser user) { final double usage = Optional.ofNullable(getCachedFreeTierUsage(user)).orElse(0.0); return !costAboveLimit(user, usage); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } | FreeTierBillingService { public boolean userHasRemainingFreeTierCredits(DbUser user) { final double usage = Optional.ofNullable(getCachedFreeTierUsage(user)).orElse(0.0); return !costAboveLimit(user, usage); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } |
@Test public void testReplaceAll_emptyMap() { final String input = "food is good for you! 2food3."; final String updated = Matchers.replaceAllInMap(Collections.emptyMap(), input); assertThat(updated).isEqualTo(input); } | public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } | Matchers { public static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source) { String result = source; for (Map.Entry<Pattern, String> entry : patternToReplacement.entrySet()) { result = entry.getKey().matcher(result).replaceAll(entry.getValue()); } return result; } private Matchers(); static Optional<String> getGroup(Matcher matcher, String groupName); static Optional<String> getGroup(Pattern pattern, String input, String groupName); static String replaceAllInMap(Map<Pattern, String> patternToReplacement, String source); } |
@Test public void testGetLong() { final Optional<Long> result = FieldValues.getLong(ROW_1, 0); assertThat(result.isPresent()).isTrue(); assertThat(result.get()).isEqualTo(LONG_VALUE); assertThat(FieldValues.getLong(ROW_1, 1).isPresent()).isFalse(); assertThat(FieldValues.getLong(ROW_1, "null_int_field").isPresent()).isFalse(); } | public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } private FieldValues(); } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } private FieldValues(); static Optional<FieldValue> getValue(FieldValueList row, int index); static Optional<FieldValue> getValue(FieldValueList row, String fieldName); static Optional<Boolean> getBoolean(FieldValueList row, int index); static Optional<Boolean> getBoolean(FieldValueList row, String fieldName); static Optional<byte[]> getBytes(FieldValueList row, int index); static Optional<byte[]> getBytes(FieldValueList row, String fieldName); static Optional<Double> getDouble(FieldValueList row, int index); static Optional<Double> getDouble(FieldValueList row, String fieldName); static Optional<Long> getLong(FieldValueList row, int index); static Optional<Long> getLong(FieldValueList row, String fieldName); static Optional<BigDecimal> getNumeric(FieldValueList row, int index); static Optional<BigDecimal> getNumeric(FieldValueList row, String fieldName); static Optional<FieldValueList> getRecord(FieldValueList row, int index); static Optional<FieldValueList> getRecord(FieldValueList row, String fieldName); static Optional<List<FieldValue>> getRepeated(FieldValueList row, int index); static Optional<List<FieldValue>> getRepeated(FieldValueList row, String fieldName); static Optional<String> getString(FieldValueList row, int index); static Optional<String> getString(FieldValueList row, String fieldName); static Optional<Long> getTimestampMicroseconds(FieldValueList row, int index); static Optional<Long> getTimestampMicroseconds(FieldValueList row, String fieldName); static Optional<DateTime> getDateTime(FieldValueList row, int index); static Optional<OffsetDateTime> getDateTime(FieldValueList row, String fieldName); @VisibleForTesting static FieldValueList buildFieldValueList(FieldList schemaFieldList, List<Object> values); } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } private FieldValues(); static Optional<FieldValue> getValue(FieldValueList row, int index); static Optional<FieldValue> getValue(FieldValueList row, String fieldName); static Optional<Boolean> getBoolean(FieldValueList row, int index); static Optional<Boolean> getBoolean(FieldValueList row, String fieldName); static Optional<byte[]> getBytes(FieldValueList row, int index); static Optional<byte[]> getBytes(FieldValueList row, String fieldName); static Optional<Double> getDouble(FieldValueList row, int index); static Optional<Double> getDouble(FieldValueList row, String fieldName); static Optional<Long> getLong(FieldValueList row, int index); static Optional<Long> getLong(FieldValueList row, String fieldName); static Optional<BigDecimal> getNumeric(FieldValueList row, int index); static Optional<BigDecimal> getNumeric(FieldValueList row, String fieldName); static Optional<FieldValueList> getRecord(FieldValueList row, int index); static Optional<FieldValueList> getRecord(FieldValueList row, String fieldName); static Optional<List<FieldValue>> getRepeated(FieldValueList row, int index); static Optional<List<FieldValue>> getRepeated(FieldValueList row, String fieldName); static Optional<String> getString(FieldValueList row, int index); static Optional<String> getString(FieldValueList row, String fieldName); static Optional<Long> getTimestampMicroseconds(FieldValueList row, int index); static Optional<Long> getTimestampMicroseconds(FieldValueList row, String fieldName); static Optional<DateTime> getDateTime(FieldValueList row, int index); static Optional<OffsetDateTime> getDateTime(FieldValueList row, String fieldName); @VisibleForTesting static FieldValueList buildFieldValueList(FieldList schemaFieldList, List<Object> values); static final int MICROSECONDS_IN_MILLISECOND; } |
@Test public void testGetDouble() { assertThat(FieldValues.getDouble(ROW_1, 2).isPresent()).isTrue(); assertThat(FieldValues.getDouble(ROW_1, "double_field").get()) .isWithin(TOLERANCE) .of(DOUBLE_VALUE); } | public static Optional<Double> getDouble(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getDoubleValue); } | FieldValues { public static Optional<Double> getDouble(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getDoubleValue); } } | FieldValues { public static Optional<Double> getDouble(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getDoubleValue); } private FieldValues(); } | FieldValues { public static Optional<Double> getDouble(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getDoubleValue); } private FieldValues(); static Optional<FieldValue> getValue(FieldValueList row, int index); static Optional<FieldValue> getValue(FieldValueList row, String fieldName); static Optional<Boolean> getBoolean(FieldValueList row, int index); static Optional<Boolean> getBoolean(FieldValueList row, String fieldName); static Optional<byte[]> getBytes(FieldValueList row, int index); static Optional<byte[]> getBytes(FieldValueList row, String fieldName); static Optional<Double> getDouble(FieldValueList row, int index); static Optional<Double> getDouble(FieldValueList row, String fieldName); static Optional<Long> getLong(FieldValueList row, int index); static Optional<Long> getLong(FieldValueList row, String fieldName); static Optional<BigDecimal> getNumeric(FieldValueList row, int index); static Optional<BigDecimal> getNumeric(FieldValueList row, String fieldName); static Optional<FieldValueList> getRecord(FieldValueList row, int index); static Optional<FieldValueList> getRecord(FieldValueList row, String fieldName); static Optional<List<FieldValue>> getRepeated(FieldValueList row, int index); static Optional<List<FieldValue>> getRepeated(FieldValueList row, String fieldName); static Optional<String> getString(FieldValueList row, int index); static Optional<String> getString(FieldValueList row, String fieldName); static Optional<Long> getTimestampMicroseconds(FieldValueList row, int index); static Optional<Long> getTimestampMicroseconds(FieldValueList row, String fieldName); static Optional<DateTime> getDateTime(FieldValueList row, int index); static Optional<OffsetDateTime> getDateTime(FieldValueList row, String fieldName); @VisibleForTesting static FieldValueList buildFieldValueList(FieldList schemaFieldList, List<Object> values); } | FieldValues { public static Optional<Double> getDouble(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getDoubleValue); } private FieldValues(); static Optional<FieldValue> getValue(FieldValueList row, int index); static Optional<FieldValue> getValue(FieldValueList row, String fieldName); static Optional<Boolean> getBoolean(FieldValueList row, int index); static Optional<Boolean> getBoolean(FieldValueList row, String fieldName); static Optional<byte[]> getBytes(FieldValueList row, int index); static Optional<byte[]> getBytes(FieldValueList row, String fieldName); static Optional<Double> getDouble(FieldValueList row, int index); static Optional<Double> getDouble(FieldValueList row, String fieldName); static Optional<Long> getLong(FieldValueList row, int index); static Optional<Long> getLong(FieldValueList row, String fieldName); static Optional<BigDecimal> getNumeric(FieldValueList row, int index); static Optional<BigDecimal> getNumeric(FieldValueList row, String fieldName); static Optional<FieldValueList> getRecord(FieldValueList row, int index); static Optional<FieldValueList> getRecord(FieldValueList row, String fieldName); static Optional<List<FieldValue>> getRepeated(FieldValueList row, int index); static Optional<List<FieldValue>> getRepeated(FieldValueList row, String fieldName); static Optional<String> getString(FieldValueList row, int index); static Optional<String> getString(FieldValueList row, String fieldName); static Optional<Long> getTimestampMicroseconds(FieldValueList row, int index); static Optional<Long> getTimestampMicroseconds(FieldValueList row, String fieldName); static Optional<DateTime> getDateTime(FieldValueList row, int index); static Optional<OffsetDateTime> getDateTime(FieldValueList row, String fieldName); @VisibleForTesting static FieldValueList buildFieldValueList(FieldList schemaFieldList, List<Object> values); static final int MICROSECONDS_IN_MILLISECOND; } |
@Test(expected = IllegalArgumentException.class) public void testGetLong_invalidFieldName() { FieldValues.getLong(ROW_1, "wrong_name"); } | public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } private FieldValues(); } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } private FieldValues(); static Optional<FieldValue> getValue(FieldValueList row, int index); static Optional<FieldValue> getValue(FieldValueList row, String fieldName); static Optional<Boolean> getBoolean(FieldValueList row, int index); static Optional<Boolean> getBoolean(FieldValueList row, String fieldName); static Optional<byte[]> getBytes(FieldValueList row, int index); static Optional<byte[]> getBytes(FieldValueList row, String fieldName); static Optional<Double> getDouble(FieldValueList row, int index); static Optional<Double> getDouble(FieldValueList row, String fieldName); static Optional<Long> getLong(FieldValueList row, int index); static Optional<Long> getLong(FieldValueList row, String fieldName); static Optional<BigDecimal> getNumeric(FieldValueList row, int index); static Optional<BigDecimal> getNumeric(FieldValueList row, String fieldName); static Optional<FieldValueList> getRecord(FieldValueList row, int index); static Optional<FieldValueList> getRecord(FieldValueList row, String fieldName); static Optional<List<FieldValue>> getRepeated(FieldValueList row, int index); static Optional<List<FieldValue>> getRepeated(FieldValueList row, String fieldName); static Optional<String> getString(FieldValueList row, int index); static Optional<String> getString(FieldValueList row, String fieldName); static Optional<Long> getTimestampMicroseconds(FieldValueList row, int index); static Optional<Long> getTimestampMicroseconds(FieldValueList row, String fieldName); static Optional<DateTime> getDateTime(FieldValueList row, int index); static Optional<OffsetDateTime> getDateTime(FieldValueList row, String fieldName); @VisibleForTesting static FieldValueList buildFieldValueList(FieldList schemaFieldList, List<Object> values); } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } private FieldValues(); static Optional<FieldValue> getValue(FieldValueList row, int index); static Optional<FieldValue> getValue(FieldValueList row, String fieldName); static Optional<Boolean> getBoolean(FieldValueList row, int index); static Optional<Boolean> getBoolean(FieldValueList row, String fieldName); static Optional<byte[]> getBytes(FieldValueList row, int index); static Optional<byte[]> getBytes(FieldValueList row, String fieldName); static Optional<Double> getDouble(FieldValueList row, int index); static Optional<Double> getDouble(FieldValueList row, String fieldName); static Optional<Long> getLong(FieldValueList row, int index); static Optional<Long> getLong(FieldValueList row, String fieldName); static Optional<BigDecimal> getNumeric(FieldValueList row, int index); static Optional<BigDecimal> getNumeric(FieldValueList row, String fieldName); static Optional<FieldValueList> getRecord(FieldValueList row, int index); static Optional<FieldValueList> getRecord(FieldValueList row, String fieldName); static Optional<List<FieldValue>> getRepeated(FieldValueList row, int index); static Optional<List<FieldValue>> getRepeated(FieldValueList row, String fieldName); static Optional<String> getString(FieldValueList row, int index); static Optional<String> getString(FieldValueList row, String fieldName); static Optional<Long> getTimestampMicroseconds(FieldValueList row, int index); static Optional<Long> getTimestampMicroseconds(FieldValueList row, String fieldName); static Optional<DateTime> getDateTime(FieldValueList row, int index); static Optional<OffsetDateTime> getDateTime(FieldValueList row, String fieldName); @VisibleForTesting static FieldValueList buildFieldValueList(FieldList schemaFieldList, List<Object> values); static final int MICROSECONDS_IN_MILLISECOND; } |
@Test(expected = ArrayIndexOutOfBoundsException.class) public void testGetLong_invalidIndex() { FieldValues.getLong(ROW_1, 999); } | public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } private FieldValues(); } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } private FieldValues(); static Optional<FieldValue> getValue(FieldValueList row, int index); static Optional<FieldValue> getValue(FieldValueList row, String fieldName); static Optional<Boolean> getBoolean(FieldValueList row, int index); static Optional<Boolean> getBoolean(FieldValueList row, String fieldName); static Optional<byte[]> getBytes(FieldValueList row, int index); static Optional<byte[]> getBytes(FieldValueList row, String fieldName); static Optional<Double> getDouble(FieldValueList row, int index); static Optional<Double> getDouble(FieldValueList row, String fieldName); static Optional<Long> getLong(FieldValueList row, int index); static Optional<Long> getLong(FieldValueList row, String fieldName); static Optional<BigDecimal> getNumeric(FieldValueList row, int index); static Optional<BigDecimal> getNumeric(FieldValueList row, String fieldName); static Optional<FieldValueList> getRecord(FieldValueList row, int index); static Optional<FieldValueList> getRecord(FieldValueList row, String fieldName); static Optional<List<FieldValue>> getRepeated(FieldValueList row, int index); static Optional<List<FieldValue>> getRepeated(FieldValueList row, String fieldName); static Optional<String> getString(FieldValueList row, int index); static Optional<String> getString(FieldValueList row, String fieldName); static Optional<Long> getTimestampMicroseconds(FieldValueList row, int index); static Optional<Long> getTimestampMicroseconds(FieldValueList row, String fieldName); static Optional<DateTime> getDateTime(FieldValueList row, int index); static Optional<OffsetDateTime> getDateTime(FieldValueList row, String fieldName); @VisibleForTesting static FieldValueList buildFieldValueList(FieldList schemaFieldList, List<Object> values); } | FieldValues { public static Optional<Long> getLong(FieldValueList row, int index) { return FieldValues.getValue(row, index).map(FieldValue::getLongValue); } private FieldValues(); static Optional<FieldValue> getValue(FieldValueList row, int index); static Optional<FieldValue> getValue(FieldValueList row, String fieldName); static Optional<Boolean> getBoolean(FieldValueList row, int index); static Optional<Boolean> getBoolean(FieldValueList row, String fieldName); static Optional<byte[]> getBytes(FieldValueList row, int index); static Optional<byte[]> getBytes(FieldValueList row, String fieldName); static Optional<Double> getDouble(FieldValueList row, int index); static Optional<Double> getDouble(FieldValueList row, String fieldName); static Optional<Long> getLong(FieldValueList row, int index); static Optional<Long> getLong(FieldValueList row, String fieldName); static Optional<BigDecimal> getNumeric(FieldValueList row, int index); static Optional<BigDecimal> getNumeric(FieldValueList row, String fieldName); static Optional<FieldValueList> getRecord(FieldValueList row, int index); static Optional<FieldValueList> getRecord(FieldValueList row, String fieldName); static Optional<List<FieldValue>> getRepeated(FieldValueList row, int index); static Optional<List<FieldValue>> getRepeated(FieldValueList row, String fieldName); static Optional<String> getString(FieldValueList row, int index); static Optional<String> getString(FieldValueList row, String fieldName); static Optional<Long> getTimestampMicroseconds(FieldValueList row, int index); static Optional<Long> getTimestampMicroseconds(FieldValueList row, String fieldName); static Optional<DateTime> getDateTime(FieldValueList row, int index); static Optional<OffsetDateTime> getDateTime(FieldValueList row, String fieldName); @VisibleForTesting static FieldValueList buildFieldValueList(FieldList schemaFieldList, List<Object> values); static final int MICROSECONDS_IN_MILLISECOND; } |
@Test public void preHandleOptions_OPTIONS() throws Exception { when(request.getMethod()).thenReturn(HttpMethods.OPTIONS); assertThat(interceptor.preHandle(request, response, handler)).isTrue(); } | @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } @Override boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler); } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } @Override boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler); static final String QUEUE_NAME_REQUEST_HEADER; static final Set<String> VALID_QUEUE_NAME_SET; } |
@Test public void prehandleForCloudTaskNoHeader() throws Exception { when(request.getMethod()).thenReturn(HttpMethods.POST); when(handler.getMethod()) .thenReturn( CloudTaskRdrExportApi.class.getMethod(CLOUD_TASK_METHOD_NAME, ArrayOfLong.class)); assertThat(interceptor.preHandle(request, response, handler)).isFalse(); } | @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } @Override boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler); } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } @Override boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler); static final String QUEUE_NAME_REQUEST_HEADER; static final Set<String> VALID_QUEUE_NAME_SET; } |
@Test public void prehandleForCloudTaskWithBadHeader() throws Exception { when(request.getMethod()).thenReturn(HttpMethods.POST); when(handler.getMethod()) .thenReturn( CloudTaskRdrExportApi.class.getMethod(CLOUD_TASK_METHOD_NAME, ArrayOfLong.class)); when(request.getHeader(CloudTaskInterceptor.QUEUE_NAME_REQUEST_HEADER)).thenReturn("asdf"); assertThat(interceptor.preHandle(request, response, handler)).isFalse(); } | @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } @Override boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler); } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } @Override boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler); static final String QUEUE_NAME_REQUEST_HEADER; static final Set<String> VALID_QUEUE_NAME_SET; } |
@Test public void prehandleForCloudTaskWithHeader() throws Exception { when(request.getMethod()).thenReturn(HttpMethods.POST); when(handler.getMethod()) .thenReturn( CloudTaskRdrExportApi.class.getMethod(CLOUD_TASK_METHOD_NAME, ArrayOfLong.class)); when(request.getHeader(CloudTaskInterceptor.QUEUE_NAME_REQUEST_HEADER)) .thenReturn("rdrExportQueue"); assertThat(interceptor.preHandle(request, response, handler)).isTrue(); } | @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } @Override boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler); } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } @Override boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler); static final String QUEUE_NAME_REQUEST_HEADER; static final Set<String> VALID_QUEUE_NAME_SET; } |
@Test public void prehandleForNonCloudTask() throws Exception { when(request.getMethod()).thenReturn(HttpMethods.GET); when(handler.getMethod()).thenReturn(WorkspacesApi.class.getMethod("getWorkspaces")); assertThat(interceptor.preHandle(request, response, handler)).isTrue(); } | @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } @Override boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler); } | CloudTaskInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (request.getMethod().equals(HttpMethods.OPTIONS)) { return true; } HandlerMethod method = (HandlerMethod) handler; ApiOperation apiOp = AnnotationUtils.findAnnotation(method.getMethod(), ApiOperation.class); if (apiOp == null) { return true; } boolean requireCloudTaskHeader = false; for (String tag : apiOp.tags()) { if (CLOUD_TASK_TAG.equals(tag)) { requireCloudTaskHeader = true; break; } } boolean hasQueueNameHeader = VALID_QUEUE_NAME_SET.contains(request.getHeader(QUEUE_NAME_REQUEST_HEADER)); if (requireCloudTaskHeader && !hasQueueNameHeader) { response.sendError( HttpServletResponse.SC_FORBIDDEN, String.format( "cloud task endpoints are only invocable via app engine cloudTask, and " + "require the '%s' header", QUEUE_NAME_REQUEST_HEADER)); return false; } return true; } @Override boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler); static final String QUEUE_NAME_REQUEST_HEADER; static final Set<String> VALID_QUEUE_NAME_SET; } |
@Test public void userHasRemainingFreeTierCredits() { workbenchConfig.billing.defaultFreeCreditsDollarLimit = 100.0; final DbUser user1 = createUser(SINGLE_WORKSPACE_TEST_USER); createWorkspace(user1, SINGLE_WORKSPACE_TEST_PROJECT); doReturn(mockBQTableSingleResult(99.99)).when(bigQueryService).executeQuery(any()); freeTierBillingService.checkFreeTierBillingUsage(); assertThat(freeTierBillingService.userHasRemainingFreeTierCredits(user1)).isTrue(); doReturn(mockBQTableSingleResult(100.01)).when(bigQueryService).executeQuery(any()); freeTierBillingService.checkFreeTierBillingUsage(); assertThat(freeTierBillingService.userHasRemainingFreeTierCredits(user1)).isFalse(); workbenchConfig.billing.defaultFreeCreditsDollarLimit = 200.0; assertThat(freeTierBillingService.userHasRemainingFreeTierCredits(user1)).isTrue(); } | public boolean userHasRemainingFreeTierCredits(DbUser user) { final double usage = Optional.ofNullable(getCachedFreeTierUsage(user)).orElse(0.0); return !costAboveLimit(user, usage); } | FreeTierBillingService { public boolean userHasRemainingFreeTierCredits(DbUser user) { final double usage = Optional.ofNullable(getCachedFreeTierUsage(user)).orElse(0.0); return !costAboveLimit(user, usage); } } | FreeTierBillingService { public boolean userHasRemainingFreeTierCredits(DbUser user) { final double usage = Optional.ofNullable(getCachedFreeTierUsage(user)).orElse(0.0); return !costAboveLimit(user, usage); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); } | FreeTierBillingService { public boolean userHasRemainingFreeTierCredits(DbUser user) { final double usage = Optional.ofNullable(getCachedFreeTierUsage(user)).orElse(0.0); return !costAboveLimit(user, usage); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } | FreeTierBillingService { public boolean userHasRemainingFreeTierCredits(DbUser user) { final double usage = Optional.ofNullable(getCachedFreeTierUsage(user)).orElse(0.0); return !costAboveLimit(user, usage); } @Autowired FreeTierBillingService(
BigQueryService bigQueryService,
Clock clock,
MailService mailService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserDao userDao,
UserServiceAuditor userServiceAuditor,
WorkspaceDao workspaceDao,
WorkspaceFreeTierUsageDao workspaceFreeTierUsageDao); double getWorkspaceFreeTierBillingUsage(DbWorkspace dbWorkspace); void checkFreeTierBillingUsage(); @Nullable Double getCachedFreeTierUsage(DbUser user); boolean userHasRemainingFreeTierCredits(DbUser user); double getUserFreeTierDollarLimit(DbUser user); boolean maybeSetDollarLimitOverride(DbUser user, double newDollarLimit); Map<Long, Double> getUserIdToTotalCost(); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.