Skip to content

Commit bba016b

Browse files
dmcg310dmcg310
committed
refactor: use new custom exceptions everywhere
1 parent 4e48f7f commit bba016b

30 files changed

Lines changed: 450 additions & 472 deletions

‎src/main/java/com/syncapi/controller/auth/AuthController.java‎

Lines changed: 6 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,6 @@
88
import com.syncapi.util.Util;
99
import jakarta.validation.Valid;
1010
import org.springframework.beans.factory.annotation.Autowired;
11-
import org.springframework.http.HttpStatus;
1211
import org.springframework.http.ResponseEntity;
1312
import org.springframework.web.bind.annotation.PatchMapping;
1413
import org.springframework.web.bind.annotation.PostMapping;
@@ -24,34 +23,22 @@ public class AuthController {
2423

2524
@PostMapping("/register")
2625
public ResponseEntity<AuthResponse> register(@Valid @RequestBody RegisterRequest request) {
27-
try {
28-
AuthResponse auth = authService.register(request);
26+
AuthResponse auth = authService.register(request);
2927

30-
return ResponseEntity.ok(auth);
31-
} catch (RuntimeException e) {
32-
return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
33-
}
28+
return ResponseEntity.ok(auth);
3429
}
3530

3631
@PostMapping("/login")
3732
public ResponseEntity<AuthResponse> login(@Valid @RequestBody LoginRequest request) {
38-
try {
39-
AuthResponse auth = authService.login(request);
33+
AuthResponse auth = authService.login(request);
4034

41-
return ResponseEntity.ok(auth);
42-
} catch (RuntimeException e) {
43-
return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
44-
}
35+
return ResponseEntity.ok(auth);
4536
}
4637

4738
@PatchMapping("/password")
4839
public ResponseEntity<AuthResponse> updatePassword(@Valid @RequestBody UpdatePasswordRequest request) {
49-
try {
50-
AuthResponse auth = authService.updatePassword(request, Util.getCurrentUserEmail());
40+
AuthResponse auth = authService.updatePassword(request, Util.getCurrentUserEmail());
5141

52-
return ResponseEntity.ok(auth);
53-
} catch (RuntimeException e) {
54-
return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
55-
}
42+
return ResponseEntity.ok(auth);
5643
}
5744
}

‎src/main/java/com/syncapi/controller/environment/EnvironmentController.java‎

Lines changed: 26 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -28,87 +28,59 @@ public class EnvironmentController {
2828

2929
@GetMapping
3030
public ResponseEntity<List<EnvironmentResponse>> getEnvironmentsByWorkspace(@PathVariable Long workspaceId) {
31-
try {
32-
List<EnvironmentResponse> environments = environmentService.getEnvironmentsByWorkspace(workspaceId,
33-
Util.getCurrentUserEmail());
34-
35-
return ResponseEntity.ok(environments);
36-
} catch (RuntimeException e) {
37-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
38-
}
31+
List<EnvironmentResponse> environments = environmentService.getEnvironmentsByWorkspace(workspaceId,
32+
Util.getCurrentUserEmail());
33+
34+
return ResponseEntity.ok(environments);
3935
}
4036

4137
@GetMapping("/{environmentId}")
4238
public ResponseEntity<EnvironmentResponse> getEnvironment(@PathVariable Long environmentId) {
43-
try {
44-
EnvironmentResponse environment = environmentService.getEnvironmentById(environmentId,
45-
Util.getCurrentUserEmail());
46-
47-
return ResponseEntity.ok(environment);
48-
} catch (RuntimeException e) {
49-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
50-
}
39+
EnvironmentResponse environment = environmentService.getEnvironmentById(environmentId,
40+
Util.getCurrentUserEmail());
41+
42+
return ResponseEntity.ok(environment);
5143
}
5244

5345
@PostMapping
5446
public ResponseEntity<EnvironmentResponse> createEnvironment(@PathVariable Long workspaceId,
5547
@Valid @RequestBody EnvironmentRequest request) {
56-
try {
57-
EnvironmentResponse environment = environmentService.createEnvironment(workspaceId, request,
58-
Util.getCurrentUserEmail());
59-
60-
return ResponseEntity.status(HttpStatus.CREATED).body(environment);
61-
} catch (RuntimeException e) {
62-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
63-
}
48+
EnvironmentResponse environment = environmentService.createEnvironment(workspaceId, request,
49+
Util.getCurrentUserEmail());
50+
51+
return ResponseEntity.status(HttpStatus.CREATED).body(environment);
6452
}
6553

6654
@PutMapping("/{environmentId}")
6755
public ResponseEntity<EnvironmentResponse> updateEnvironment(@PathVariable Long environmentId,
6856
@Valid @RequestBody EnvironmentRequest request) {
69-
try {
70-
EnvironmentResponse environment = environmentService.updateEnvironment(environmentId, request,
71-
Util.getCurrentUserEmail());
72-
73-
return ResponseEntity.ok(environment);
74-
} catch (RuntimeException e) {
75-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
76-
}
57+
EnvironmentResponse environment = environmentService.updateEnvironment(environmentId, request,
58+
Util.getCurrentUserEmail());
59+
60+
return ResponseEntity.ok(environment);
7761
}
7862

7963
@PatchMapping("/{environmentId}")
8064
public ResponseEntity<EnvironmentResponse> patchEnvironment(@PathVariable Long environmentId,
8165
@RequestBody EnvironmentRequest request) {
82-
try {
83-
EnvironmentResponse environment = environmentService.patchEnvironment(environmentId, request,
84-
Util.getCurrentUserEmail());
85-
86-
return ResponseEntity.ok(environment);
87-
} catch (RuntimeException e) {
88-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
89-
}
66+
EnvironmentResponse environment = environmentService.patchEnvironment(environmentId, request,
67+
Util.getCurrentUserEmail());
68+
69+
return ResponseEntity.ok(environment);
9070
}
9171

9272
@DeleteMapping("/{environmentId}")
9373
public ResponseEntity<Void> deleteEnvironment(@PathVariable Long environmentId) {
94-
try {
95-
environmentService.deleteEnvironment(environmentId, Util.getCurrentUserEmail());
74+
environmentService.deleteEnvironment(environmentId, Util.getCurrentUserEmail());
9675

97-
return ResponseEntity.noContent().build();
98-
} catch (RuntimeException e) {
99-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
100-
}
76+
return ResponseEntity.noContent().build();
10177
}
10278

10379
@PatchMapping("/{environmentId}/activate")
10480
public ResponseEntity<EnvironmentResponse> activateEnvironment(@PathVariable Long environmentId) {
105-
try {
106-
EnvironmentResponse environment = environmentService.setEnvironmentActiveStatus(environmentId, true,
107-
Util.getCurrentUserEmail());
108-
109-
return ResponseEntity.ok(environment);
110-
} catch (RuntimeException e) {
111-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
112-
}
81+
EnvironmentResponse environment = environmentService.setEnvironmentActiveStatus(environmentId, true,
82+
Util.getCurrentUserEmail());
83+
84+
return ResponseEntity.ok(environment);
11385
}
11486
}

‎src/main/java/com/syncapi/controller/environment/EnvironmentVariableController.java‎

Lines changed: 11 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -27,29 +27,21 @@ public class EnvironmentVariableController {
2727

2828
@GetMapping
2929
public ResponseEntity<List<EnvironmentVariableResponse>> getVariables(@PathVariable Long environmentId) {
30-
try {
31-
List<EnvironmentVariableResponse> variables = environmentVariableService.getVariablesByEnvironment(
32-
environmentId, Util.getCurrentUserEmail());
30+
List<EnvironmentVariableResponse> variables = environmentVariableService.getVariablesByEnvironment(
31+
environmentId, Util.getCurrentUserEmail());
3332

34-
return ResponseEntity.ok(variables);
35-
} catch (RuntimeException e) {
36-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
37-
}
33+
return ResponseEntity.ok(variables);
3834
}
3935

4036
@PostMapping
4137
public ResponseEntity<EnvironmentVariableResponse> addVariable(
4238
@PathVariable Long environmentId,
4339
@Valid @RequestBody EnvironmentVariableRequest request
4440
) {
45-
try {
46-
EnvironmentVariableResponse created = environmentVariableService.addVariable(environmentId, request,
47-
Util.getCurrentUserEmail());
41+
EnvironmentVariableResponse created = environmentVariableService.addVariable(environmentId, request,
42+
Util.getCurrentUserEmail());
4843

49-
return ResponseEntity.status(HttpStatus.CREATED).body(created);
50-
} catch (RuntimeException e) {
51-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
52-
}
44+
return ResponseEntity.status(HttpStatus.CREATED).body(created);
5345
}
5446

5547
@PutMapping("/{variableId}")
@@ -58,25 +50,17 @@ public ResponseEntity<EnvironmentVariableResponse> updateVariable(
5850
@PathVariable Long variableId,
5951
@Valid @RequestBody EnvironmentVariableRequest request
6052
) {
61-
try {
62-
EnvironmentVariableResponse updated = environmentVariableService.updateVariable(environmentId, variableId,
63-
request, Util.getCurrentUserEmail());
53+
EnvironmentVariableResponse updated = environmentVariableService.updateVariable(environmentId, variableId,
54+
request, Util.getCurrentUserEmail());
6455

65-
return ResponseEntity.ok(updated);
66-
} catch (RuntimeException e) {
67-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
68-
}
56+
return ResponseEntity.ok(updated);
6957
}
7058

7159
@DeleteMapping("/{variableId}")
7260
public ResponseEntity<Void> deleteVariable(@PathVariable Long environmentId,
7361
@PathVariable Long variableId) {
74-
try {
75-
environmentVariableService.deleteVariable(environmentId, variableId, Util.getCurrentUserEmail());
62+
environmentVariableService.deleteVariable(environmentId, variableId, Util.getCurrentUserEmail());
7663

77-
return ResponseEntity.noContent().build();
78-
} catch (RuntimeException e) {
79-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
80-
}
64+
return ResponseEntity.noContent().build();
8165
}
8266
}

‎src/main/java/com/syncapi/controller/folder/FolderController.java‎

Lines changed: 12 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -28,70 +28,46 @@ public class FolderController {
2828

2929
@GetMapping
3030
public ResponseEntity<List<FolderResponse>> getFoldersByWorkspace(@PathVariable Long workspaceId) {
31-
try {
32-
List<FolderResponse> folders = folderService.getFoldersByWorkspace(workspaceId, Util.getCurrentUserEmail());
31+
List<FolderResponse> folders = folderService.getFoldersByWorkspace(workspaceId, Util.getCurrentUserEmail());
3332

34-
return ResponseEntity.ok(folders);
35-
} catch (RuntimeException e) {
36-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
37-
}
33+
return ResponseEntity.ok(folders);
3834
}
3935

4036
@GetMapping("/{folderId}")
4137
public ResponseEntity<FolderResponse> getFolder(@PathVariable Long folderId) {
42-
try {
43-
FolderResponse folder = folderService.getFolderById(folderId, Util.getCurrentUserEmail());
38+
FolderResponse folder = folderService.getFolderById(folderId, Util.getCurrentUserEmail());
4439

45-
return ResponseEntity.ok(folder);
46-
} catch (RuntimeException e) {
47-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
48-
}
40+
return ResponseEntity.ok(folder);
4941
}
5042

5143
@PostMapping
5244
public ResponseEntity<FolderResponse> createFolder(@PathVariable Long workspaceId,
5345
@Valid @RequestBody FolderRequest request) {
54-
try {
55-
FolderResponse folder = folderService.createFolder(workspaceId, request, Util.getCurrentUserEmail());
46+
FolderResponse folder = folderService.createFolder(workspaceId, request, Util.getCurrentUserEmail());
5647

57-
return ResponseEntity.status(HttpStatus.CREATED).body(folder);
58-
} catch (RuntimeException e) {
59-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
60-
}
48+
return ResponseEntity.status(HttpStatus.CREATED).body(folder);
6149
}
6250

6351
@PutMapping("/{folderId}")
6452
public ResponseEntity<FolderResponse> updateFolder(@PathVariable Long folderId,
6553
@Valid @RequestBody FolderRequest request) {
66-
try {
67-
FolderResponse folder = folderService.updateFolder(folderId, request, Util.getCurrentUserEmail());
54+
FolderResponse folder = folderService.updateFolder(folderId, request, Util.getCurrentUserEmail());
6855

69-
return ResponseEntity.ok(folder);
70-
} catch (RuntimeException e) {
71-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
72-
}
56+
return ResponseEntity.ok(folder);
7357
}
7458

7559
@PatchMapping("/{folderId}")
7660
public ResponseEntity<FolderResponse> patchFolder(@PathVariable Long folderId,
7761
@RequestBody FolderRequest request) {
78-
try {
79-
FolderResponse folder = folderService.patchFolder(folderId, request, Util.getCurrentUserEmail());
62+
FolderResponse folder = folderService.patchFolder(folderId, request, Util.getCurrentUserEmail());
8063

81-
return ResponseEntity.ok(folder);
82-
} catch (RuntimeException e) {
83-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
84-
}
64+
return ResponseEntity.ok(folder);
8565
}
8666

8767
@DeleteMapping("/{folderId}")
8868
public ResponseEntity<Void> deleteFolder(@PathVariable Long folderId) {
89-
try {
90-
folderService.deleteFolder(folderId, Util.getCurrentUserEmail());
69+
folderService.deleteFolder(folderId, Util.getCurrentUserEmail());
9170

92-
return ResponseEntity.noContent().build();
93-
} catch (RuntimeException e) {
94-
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
95-
}
71+
return ResponseEntity.noContent().build();
9672
}
9773
}

0 commit comments

Comments
 (0)