RaidBuilder/RaidBuilderWeb
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Show better error messages

Browse Source
This commit is contained in:
Mattrixwv
2025-03-23 11:47:10 -04:00
parent 3b738c337b
commit c5fbb1d83f
12 changed files with 1206 additions and 599 deletions
Download Patch File Download Diff File Expand all files Collapse all files

228
src/hooks/AccountHooks.ts
View File

@@ -17,17 +17,24 @@ export function useGetAccounts(page: number, pageSize: number, searchTerm?: stri
params.append("searchTerm", searchTerm ?? "");
}
try{
const response = await api.get(`/account?${params}`);
if(response.status !== 200){
throw new Error("Failed to get accounts");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as Account[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -42,17 +49,24 @@ export function useGetAccountsByRaidGroup(raidGroupId: string, page: number, pag
params.append("searchTerm", searchTerm ?? "");
}
try{
const response = await api.get(`/account/raidGroup/${raidGroupId}?${params}`);
if(response.status !== 200){
throw new Error("Failed to get accounts");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as Account[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -60,16 +74,23 @@ export function useGetRaidGroupPermissionsForAccount(raidGroupId?: string, accou
return useQuery({
queryKey: ["accounts", "raidGroup", raidGroupId, "account", accountId],
queryFn: async () => {
try{
const response = await api.get(`/account/${accountId}/raidGroup/${raidGroupId}/permission`);
if(response.status !== 200){
throw new Error("Failed to get permissions");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.permission as RaidGroupPermissionType;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!raidGroupId && !!accountId
});
@@ -86,18 +107,24 @@ export function useGetAccountsCount(searchTerm?: string){
return useQuery({
queryKey: [ "accounts", "count", searchTerm],
queryFn: async () => {
try{
const response = await api.get(`/account/count?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get accounts count");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -111,18 +138,24 @@ export function useGetAccountsByRaidGroupCount(raidGroupId: string, searchTerm?:
return useQuery({
queryKey: [ "accounts", "raidGroup", raidGroupId, "count", searchTerm],
queryFn: async () => {
try{
const response = await api.get(`/account/raidGroup/${raidGroupId}/count?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get accounts count");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -130,16 +163,23 @@ export function useGetTutorialsStatus(accountId: string | null){
return useQuery({
queryKey: ["tutorials", "account", accountId],
queryFn: async () => {
try{
const response = await api.get(`/account/tutorial`);
if(response.status !== 200){
throw new Error("Failed to get tutorials status");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as AccountTutorialStatus;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!accountId
});
@@ -149,15 +189,22 @@ export function useUpdateTutorialsStatus(){
return useMutation({
mutationKey: ["tutorials", "accounts"],
mutationFn: async (tutorials: AccountTutorialStatus) => {
try{
const response = await api.put(`/account/tutorial`, tutorials);
if(response.status !== 200){
throw new Error("Failed to update tutorials status");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -192,14 +239,21 @@ export function useForcePasswordReset(accountId: string){
return useMutation({
mutationKey: ["forcePasswordReset", accountId],
mutationFn: async () => {
try{
const response = await api.put(`/account/${accountId}/forcePasswordReset`);
if(response.status !== 200){
throw new Error("Failed to force password reset");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["accounts"] });
@@ -214,16 +268,23 @@ export function useResetPassword(accountId: string){
return useMutation({
mutationKey: ["resetPassword", accountId],
mutationFn: async (password: string) => {
try{
const response = await api.put(`/account/${accountId}/resetPassword`, {
password
});
if(response.status !== 200){
throw new Error("Failed to reset password");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["accounts"] });
@@ -238,14 +299,21 @@ export function useRevokeRefreshToken(accountId: string){
return useMutation({
mutationKey: ["revokeRefreshToken", accountId],
mutationFn: async () => {
try{
const response = await api.put(`/account/${accountId}/revokeRefreshToken`);
if(response.status !== 200){
throw new Error("Failed to revoke refresh token");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["accounts"] });
@@ -260,14 +328,21 @@ export function useCreateAccount(){
return useMutation({
mutationKey: ["createAccount"],
mutationFn: async (account: Account) => {
try{
const response = await api.post("/account", account);
if(response.status !== 200){
throw new Error("Failed to create account");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["accounts"] });
@@ -282,14 +357,21 @@ export function useUpdateAccount(){
return useMutation({
mutationKey: ["updateAccount"],
mutationFn: async (account: Account) => {
try{
const response = await api.put(`/account/${account.accountId}`, account);
if(response.status !== 200){
throw new Error("Failed to update account");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["accounts"] });
@@ -304,16 +386,23 @@ export function useUpdateRaidGroupPermissionsForAccount(raidGroupId?: string, ac
return useMutation({
mutationKey: ["updateRaidGroupPermissionsForAccount", raidGroupId, accountId],
mutationFn: async (permission: RaidGroupPermissionType) => {
try{
const response = await api.put(`/account/${accountId}/raidGroup/${raidGroupId}/permission`, {
permission
});
if(response.status !== 200){
throw new Error("Failed to update permissions");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["accounts"] });
@@ -328,14 +417,21 @@ export function useDeleteAccount(accountId: string){
return useMutation({
mutationKey: ["deleteAccount", accountId],
mutationFn: async () => {
try{
const response = await api.delete(`/account/${accountId}`);
if(response.status !== 200){
throw new Error("Failed to delete account");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["accounts"] });
@@ -351,18 +447,24 @@ export function useRemoveAccountFromRaidGroup(raidGroupId?: string, accountId?:
return useMutation({
mutationKey: ["removeAccountFromRaidGroup", raidGroupId, accountId],
mutationFn: async () => {
try{
const response = await api.delete(`/account/${accountId}/raidGroup/${raidGroupId}/permission`);
if(response.status !== 200){
throw new Error("Failed to remove account from raid group");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["accounts"] });
}
});
}

15
src/hooks/AuthHooks.ts
View File

@@ -8,15 +8,22 @@ export function useSignup(){
return useMutation({
mutationKey: ["signup"],
mutationFn: async (account: Account) => {
try{
const response = await api.post("/auth/signup", account);
if(response.status !== 200){
throw new Error("Failed to signup");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}

150
src/hooks/CalendarHooks.ts
View File

@@ -1,23 +1,31 @@
import { CalendarEvent } from "@/interface/Calendar";
import { api } from "@/util/AxiosUtil";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AxiosError } from "axios";
export function useGetGameCalendar(gameId: string){
return useQuery({
queryKey: ["gameCalendar", gameId],
queryFn: async () => {
try{
const response = await api.get(`/calendar/game/${gameId}`);
if(response.status !== 200){
throw new Error("Failed to get game calendar");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as CalendarEvent[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -25,17 +33,24 @@ export function useGetRaidGroupCalendar(raidGroupId: string){
return useQuery({
queryKey: ["raidGroupCalendar", raidGroupId],
queryFn: async () => {
try{
const response = await api.get(`/calendar/raidGroup/${raidGroupId}`);
if(response.status !== 200){
throw new Error("Failed to get raid group calendar");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as CalendarEvent[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -46,14 +61,21 @@ export function useCreateGameCalendarEvent(gameId: string){
return useMutation({
mutationFn: async (calendarEvent: CalendarEvent) => {
try{
const response = await api.post(`/calendar/game/${gameId}`, {...calendarEvent, gameCalendarEventId: calendarEvent.calendarEventId, calendarEventId: undefined});
if(response.status !== 200){
throw new Error("Failed to create calendar event");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["gameCalendar"]})
@@ -67,14 +89,26 @@ export function useUpdateGameCalendarEvent(gameId: string){
return useMutation({
mutationFn: async (calendarEvent: CalendarEvent) => {
const response = await api.put(`/calendar/game/${gameId}`, {...calendarEvent, gameCalendarEventId: calendarEvent.calendarEventId, calendarEventId: undefined});
try{
const response = await api.put(`/calendar/game/${gameId}`,
{
...calendarEvent,
gameCalendarEventId: calendarEvent.calendarEventId,
calendarEventId: undefined
});
if(response.status !== 200){
throw new Error("Failed to update calendar event");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["gameCalendar"]})
@@ -88,14 +122,21 @@ export function useDeleteGameCalendarEvent(gameId: string){
return useMutation({
mutationFn: async (calendarEvent: CalendarEvent) => {
try{
const response = await api.delete(`/calendar/game/${gameId}/${calendarEvent.calendarEventId}`);
if(response.status !== 200){
throw new Error("Failed to delete calendar event");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["gameCalendar"]})
@@ -109,14 +150,26 @@ export function useCreateRaidGroupCalendarEvent(raidGroupId: string){
return useMutation({
mutationFn: async (calendarEvent: CalendarEvent) => {
const response = await api.post(`/calendar/raidGroup/${raidGroupId}`, {...calendarEvent, raidGroupCalendarEventId: calendarEvent.calendarEventId, calendarEventId: undefined});
try{
const response = await api.post(`/calendar/raidGroup/${raidGroupId}`,
{
...calendarEvent,
raidGroupCalendarEventId: calendarEvent.calendarEventId,
calendarEventId: undefined
});
if(response.status !== 200){
throw new Error("Failed to create calendar event");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidGroupCalendar"]})
@@ -130,14 +183,21 @@ export function useUpdateRaidGroupCalendarEvent(raidGroupId: string){
return useMutation({
mutationFn: async (calendarEvent: CalendarEvent) => {
try{
const response = await api.put(`/calendar/raidGroup/${raidGroupId}`, {...calendarEvent, raidGroupCalendarEventId: calendarEvent.calendarEventId, calendarEventId: undefined});
if(response.status !== 200){
throw new Error("Failed to update calendar event");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidGroupCalendar"]})
@@ -151,14 +211,21 @@ export function useDeleteRaidGroupCalendarEvent(raidGroupId: string){
return useMutation({
mutationFn: async (calendarEvent: CalendarEvent) => {
try{
const response = await api.delete(`/calendar/raidGroup/${raidGroupId}/${calendarEvent.calendarEventId}`);
if(response.status !== 200){
throw new Error("Failed to delete calendar event");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidGroupCalendar"]})
@@ -170,16 +237,23 @@ export function useGetRaidInstanceCalendarEvents(raidGroupId?: string){
return useQuery({
queryKey: ["raidInstanceCalendarEvents", raidGroupId],
queryFn: async () => {
try{
const response = await api.get(`/calendar/raidGroup/${raidGroupId}/raidInstance`);
if(response.status !== 200){
throw new Error("Failed to get raid instance calendar events");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as CalendarEvent[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!raidGroupId && raidGroupId !== ""
});

94
src/hooks/ClassGroupHooks.ts
View File

@@ -1,6 +1,7 @@
import { ClassGroup } from "@/interface/ClassGroup";
import { api } from "@/util/AxiosUtil";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AxiosError } from "axios";
export function useGetClassGroups(raidGroupId: string, page: number, pageSize: number, searchTerm?: string){
@@ -14,16 +15,23 @@ export function useGetClassGroups(raidGroupId: string, page: number, pageSize: n
params.append("searchTerm", searchTerm);
}
try{
const response = await api.get(`/raidGroup/${raidGroupId}/classGroup?${params}`);
if(response.status !== 200){
throw new Error("Failed to get class groups");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as ClassGroup[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!raidGroupId
});
@@ -39,17 +47,24 @@ export function useGetClassGroupsCount(raidGroupId: string, searchTerm?: string)
return useQuery({
queryKey: ["classGroups", "count", searchTerm],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/classGroup/count?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get class groups count");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -57,16 +72,23 @@ export function useGetClassGroupsByRaidLayout(raidGroupId: string, raidLayoutId:
return useQuery({
queryKey: ["classGroups", "raidLayout", raidLayoutId],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/classGroup/raidLayout/${raidLayoutId}`);
if(response.status !== 200){
throw new Error("Failed to get class groups");
}
else if(response.data.error){
if(response.data.error){
throw new Error(response.data.errors.join(", "));
}
return response.data as (ClassGroup | null)[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!raidGroupId && !!raidLayoutId
})
@@ -80,6 +102,7 @@ export function useCreateClassGroup(raidGroupId: string){
return useMutation({
mutationKey: ["createClassGroup"],
mutationFn: async ({classGroupName, gameClassIds}:{classGroupName: string; gameClassIds: string[];}) => {
try{
const response = await api.post(`/raidGroup/${raidGroupId}/classGroup`,
{
classGroup: {
@@ -87,15 +110,20 @@ export function useCreateClassGroup(raidGroupId: string){
raidGroupId: raidGroupId
},
gameClassIds
}
);
});
if(response.status !== 200){
throw new Error("Failed to create class group");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({queryKey: ["classGroups"]});
@@ -110,6 +138,7 @@ export function useUpdateClassGroup(raidGroupId: string){
return useMutation({
mutationKey: ["updateClassGroup"],
mutationFn: async ({classGroup, gameClassIds}:{classGroup: ClassGroup; gameClassIds: string[];}) => {
try{
const response = await api.put(`/raidGroup/${raidGroupId}/classGroup/${classGroup.classGroupId}`,
{
classGroup,
@@ -117,12 +146,18 @@ export function useUpdateClassGroup(raidGroupId: string){
}
);
if(response.status !== 200){
throw new Error("Failed to update class group");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({queryKey: ["gameClasses", "classGroups"]});
@@ -138,14 +173,21 @@ export function useDeleteClassGroup(raidGroupId: string, classGroupId: string){
return useMutation({
mutationKey: ["deleteClassGroup", classGroupId, raidGroupId],
mutationFn: async () => {
try{
const response = await api.delete(`/raidGroup/${raidGroupId}/classGroup/${classGroupId}`);
if(response.status !== 200){
throw new Error("Failed to delete class group");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({queryKey: ["classGroups"]});

106
src/hooks/GameClassHooks.ts
View File

@@ -1,22 +1,30 @@
import { GameClass } from "@/interface/GameClass";
import { api } from "@/util/AxiosUtil";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AxiosError } from "axios";
export function useGetGameClass(gameClassId: string){
return useQuery({
queryKey: ["gameClasses", gameClassId],
queryFn: async () => {
try{
const response = await api.get(`/gameClass/${gameClassId}`);
if(response.status !== 200){
throw new Error("Failed to get game class");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as GameClass;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!gameClassId
})
@@ -33,17 +41,24 @@ export function useGetGameClasses(gameId: string, page: number, pageSize: number
params.append("searchTerm", searchTerm);
}
try{
const response = await api.get(`/gameClass/game/${gameId}?${params}`);
if(response.status !== 200){
throw new Error("Failed to get game classes");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as GameClass[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -51,16 +66,23 @@ export function useGetGameClassesByClassGroup(classGroupId?: string){
return useQuery({
queryKey: ["gameClasses", "classGroups", classGroupId],
queryFn: async () => {
try{
const response = await api.get(`/gameClass/classGroup/${classGroupId}`);
if(response.status !== 200){
throw new Error("Failed to get game classes");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as GameClass[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!classGroupId
});
@@ -77,17 +99,24 @@ export function useGetGameClassesCount(gameId: string, searchTerm?: string){
return useQuery({
queryKey: ["gameClasses", gameId, "count", searchTerm],
queryFn: async () => {
try{
const response = await api.get(`/gameClass/game/${gameId}/count?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get game classes count");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -106,17 +135,24 @@ export function useCreateGameClass(){
formData.append("gameClassName", gameClassName);
formData.append("gameId", gameId);
try{
const response = await api.post(
`/gameClass/game/${gameId}`,
formData
);
if(response.status !== 200){
throw new Error("Failed to create game class");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["gameClasses"] });
@@ -141,14 +177,21 @@ export function useUpdateGameClass(){
formData.append("gameClassIcon", gameClass.gameClassIcon);
}
try{
const response = await api.put(`/gameClass/${gameClass.gameClassId}/game/${gameClass.gameId}`, formData);
if(response.status !== 200){
throw new Error("Failed to update game class");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["gameClasses"] });
@@ -163,14 +206,21 @@ export function useDeleteGameClass(){
return useMutation({
mutationKey: ["deleteGameClass"],
mutationFn: async (gameClass: GameClass) => {
try{
const response = await api.delete(`/gameClass/${gameClass.gameClassId}/game/${gameClass.gameId}`);
if(response.status !== 200){
throw new Error("Failed to delete game class");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["gameClasses"] });

76
src/hooks/GameHooks.ts
View File

@@ -8,16 +8,23 @@ export function useGetGame(gameId: string, disabled: boolean){
return useQuery({
queryKey: ["games", gameId],
queryFn: async () => {
try{
const response = await api.get(`/game/${gameId}`);
if(response.status !== 200){
throw new Error("Failed to get game");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data?.gameId ? response.data as Game : undefined;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !disabled
});
@@ -34,7 +41,6 @@ export function useGetGames(page: number, pageSize: number, searchTerm?: string)
params.append("searchTerm", searchTerm);
}
//TODO: Change all queries to follow this pattern
try{
const response = await api.get(`/game?${params}`);
@@ -62,17 +68,24 @@ export function useGetGamesCount(searchTerm?: string){
return useQuery({
queryKey: ["games", "count", searchTerm],
queryFn: async () => {
try{
const response = await api.get(`/game/count?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get games count");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -89,17 +102,24 @@ export function useCreateGame(){
}
formData.append("gameName", gameName);
try{
const response = await api.post(
"/game",
formData
);
if(response.status !== 200){
throw new Error("Failed to create game");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["games"] });
@@ -123,14 +143,21 @@ export function useUpdateGame(){
formData.append("gameIcon", game.gameIcon);
}
try{
const response = await api.put(`/game/${game.gameId}`, formData);
if(response.status !== 200){
throw new Error("Failed to update game");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["games"] });
@@ -145,14 +172,21 @@ export function useDeleteGame(){
return useMutation({
mutationKey: ["deleteGame"],
mutationFn: async (gameId: string) => {
try{
const response = await api.delete(`/game/${gameId}`);
if(response.status !== 200){
throw new Error("Failed to delete game");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["games"] });

109
src/hooks/PersonCharacterHooks.ts
View File

@@ -1,23 +1,31 @@
import { PersonCharacter } from "@/interface/PersonCharacter";
import { api } from "@/util/AxiosUtil";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AxiosError } from "axios";
export function useGetPersonCharactersByPersonId(personId: string, raidGroupId: string){
return useQuery({
queryKey: ["personCharacters", personId],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/person/${personId}/character`);
if(response.status !== 200){
throw new Error("Failed to get person characters");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as PersonCharacter[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -33,20 +41,24 @@ export function useGetPersonCharactersByPersonIdSearch(personId: string, raidGro
return useQuery({
queryKey: ["personCharacters", personId, { page, pageSize, searchTerm }],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/person/${personId}/character/page?${params}`);
if(response.status !== 200){
throw new Error("Failed to get person characters");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
console.log("person characters");
console.log(response.data);
return response.data as PersonCharacter[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -59,17 +71,24 @@ export function useGetPersonCharactersCountByPersonIdSearch(personId: string, ra
return useQuery({
queryKey: ["personCharactersCount", personId, { searchTerm }],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/person/${personId}/character/count?${params}`);
if(response.status !== 200){
throw new Error("Failed to get person characters count");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -77,16 +96,23 @@ export function useGetPersonCharactersByRaidGroup(raidGroupId: string){
return useQuery({
queryKey: ["personCharacters", raidGroupId],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/person/character`);
if(response.status !== 200){
throw new Error("Failed to get person characters");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as PersonCharacter[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!raidGroupId
});
@@ -99,14 +125,21 @@ export function useCreatePersonCharacter(raidGroupId: string, personId: string){
return useMutation({
mutationKey: ["createPersonCharacter"],
mutationFn: async (personCharacter: PersonCharacter) => {
try{
const response = await api.post(`/raidGroup/${raidGroupId}/person/${personId}/character`, personCharacter);
if(response.status !== 200){
throw new Error("Failed to create person character");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["personCharacters"] });
@@ -121,14 +154,21 @@ export function useUpdatePersonCharacter(raidGroupId: string, personId: string){
return useMutation({
mutationKey: ["updatePersonCharacter"],
mutationFn: async (personCharacter: PersonCharacter) => {
try{
const response = await api.put(`/raidGroup/${raidGroupId}/person/${personId}/character/${personCharacter.personCharacterId}`, personCharacter);
if(response.status !== 200){
throw new Error("Failed to update person character");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["personCharacters"] });
@@ -143,14 +183,21 @@ export function useDeletePersonCharacter(raidGroupId: string, personId: string){
return useMutation({
mutationKey: ["deletePersonCharacter"],
mutationFn: async (personCharacterId: string) => {
try{
const response = await api.delete(`/raidGroup/${raidGroupId}/person/${personId}/character/${personCharacterId}`);
if(response.status !== 200){
throw new Error("Failed to delete person character");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["personCharacters"] });

91
src/hooks/PersonHooks.ts
View File

@@ -1,22 +1,30 @@
import { Person } from "@/interface/Person";
import { api } from "@/util/AxiosUtil";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AxiosError } from "axios";
export function useGetPerson(raidGroupId: string, personId: string, disabled: boolean){
return useQuery({
queryKey: ["people", raidGroupId, personId],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/person/${personId}`);
if(response.status !== 200){
throw new Error("Failed to get person");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as Person;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !disabled
});
@@ -33,17 +41,24 @@ export function useGetPeopleByRaidGroup(raidGroupId: string, page: number, pageS
searchParams.append("searchTerm", searchTerm);
}
try{
const response = await api.get(`/raidGroup/${raidGroupId}/person?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get people");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as Person[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -57,17 +72,24 @@ export function useGetPeopleByRaidGroupCount(raidGroupId: string, searchTerm?: s
return useQuery({
queryKey: ["people", raidGroupId, "count", searchTerm],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/person/count?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get people count");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -78,14 +100,21 @@ export function useCreatePerson(){
return useMutation({
mutationKey: ["createPerson"],
mutationFn: async ({raidGroupId, personName, discordId}:{raidGroupId: string; personName: string; discordId?: string;}) => {
try{
const response = await api.post(`/raidGroup/${raidGroupId}/person`, {raidGroupId, personName, discordId});
if(response.status !== 200){
throw new Error("Failed to create person");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["people"] });
@@ -100,14 +129,21 @@ export function useUpdatePerson(){
return useMutation({
mutationKey: ["updatePerson"],
mutationFn: async (person: Person) => {
try{
const response = await api.put(`/raidGroup/${person.raidGroupId}/person/${person.personId}`, person);
if(response.status !== 200){
throw new Error("Failed to update person");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["people"] });
@@ -122,14 +158,21 @@ export function useDeletePerson(){
return useMutation({
mutationKey: ["deletePerson"],
mutationFn: async ({raidGroupId, personId}:{raidGroupId: string; personId: string;}) => {
try{
const response = await api.delete(`/raidGroup/${raidGroupId}/person/${personId}`);
if(response.status !== 200){
throw new Error("Failed to delete person");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["people"] });

151
src/hooks/RaidGroupHooks.ts
View File

@@ -1,22 +1,30 @@
import { RaidGroup } from "@/interface/RaidGroup";
import { api } from "@/util/AxiosUtil";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AxiosError } from "axios";
export function useGetRaidGroup(raidGroupId: string, disabled: boolean){
return useQuery({
queryKey: ["raidGroups", raidGroupId],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}`);
if(response.status !== 200){
throw new Error("Failed to get raid group");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data?.raidGroupId ? response.data as RaidGroup : undefined;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !disabled
});
@@ -33,17 +41,24 @@ export function useGetRaidGroups(page: number, pageSize: number, searchTerm?: st
params.append("searchTerm", searchTerm);
}
try{
const response = await api.get(`/raidGroup?${params}`);
if(response.status !== 200){
throw new Error("Failed to get raid groups");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as RaidGroup[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -57,17 +72,24 @@ export function useGetRaidGroupsCount(searchTerm?: string){
return useQuery({
queryKey: ["raidGroups", "count", searchTerm],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/count?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get raid groups count");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -82,17 +104,24 @@ export function useGetRaidGroupsByGame(gameId: string, page: number, pageSize: n
params.append("searchTerm", searchTerm);
}
try{
const response = await api.get(`/raidGroup/game/${gameId}?${params}`);
if(response.status !== 200){
throw new Error("Failed to get raid groups");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as RaidGroup[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -106,17 +135,24 @@ export function useGetRaidGroupsByGameCount(gameId: string, searchTerm?: string)
return useQuery({
queryKey: ["raidGroups", gameId, "count", searchTerm],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/game/${gameId}/count?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get raid groups count");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -131,17 +167,24 @@ export function useGetRaidGroupsByAccount(accountId: string, page: number, pageS
params.append("searchTerm", searchTerm);
}
try{
const response = await api.get(`/raidGroup/account/${accountId}?${params}`);
if(response.status !== 200){
throw new Error("Failed to get raid groups");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as RaidGroup[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -155,17 +198,24 @@ export function useGetRaidGroupsCountByAccount(accountId: string, searchTerm?: s
return useQuery({
queryKey: ["raidGroups", accountId, "count", searchTerm],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/account/${accountId}/count?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get raid groups count");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -185,17 +235,24 @@ export function useCreateRaidGroup(){
formData.append("raidGroupName", raidGroupName);
formData.append("gameId", gameId);
try{
const response = await api.post(
"/raidGroup",
formData
);
if(response.status !== 200){
throw new Error("Failed to create raid group");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidGroups"] });
@@ -220,14 +277,21 @@ export function useUpdateRaidGroup(){
formData.append("raidGroupIcon", raidGroup.raidGroupIcon);
}
try{
const response = await api.put(`/raidGroup/${raidGroup.raidGroupId}`, formData);
if(response.status !== 200){
throw new Error("Failed to update raid group");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidGroups"] });
@@ -242,14 +306,21 @@ export function useDeleteRaidGroup(){
return useMutation({
mutationKey: ["deleteRaidGroup"],
mutationFn: async (raidGroupId: string) => {
try{
const response = await api.delete(`/raidGroup/${raidGroupId}`);
if(response.status !== 200){
throw new Error("Failed to delete raid group");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidGroups"] });

84
src/hooks/RaidGroupRequestHooks.ts
View File

@@ -2,6 +2,7 @@ import { RaidGroupPermissionType } from "@/interface/RaidGroup";
import { RaidGroupRequest } from "@/interface/RaidGroupRequest";
import { api } from "@/util/AxiosUtil";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AxiosError } from "axios";
export function useGetRaidGroupRequests(raidGroupId: string, page: number, pageSize: number, searchTerm?: string){
@@ -15,16 +16,23 @@ export function useGetRaidGroupRequests(raidGroupId: string, page: number, pageS
return useQuery({
queryKey: ["raidGroupRequest", raidGroupId, {page, pageSize, searchTerm}],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/raidGroupRequest?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get raid group requests");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as RaidGroupRequest[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!raidGroupId && raidGroupId !== ""
});
@@ -39,16 +47,23 @@ export function useGetRaidGroupRequestCount(raidGroupId?: string, searchTerm?: s
return useQuery({
queryKey: ["raidGroupRequest", raidGroupId, "count", searchTerm],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/raidGroupRequest/count?${searchParams}`);
if(response.status !== 200){
throw new Error("Failed to get raid group request count");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!raidGroupId && raidGroupId !== ""
});
@@ -61,16 +76,21 @@ export function useCreateRaidGroupRequest(raidGroupId: string){
return useMutation({
mutationKey: ["raidGroupRequest", raidGroupId],
mutationFn: async (requestMessage: string) => {
const response = await api.post(`/raidGroup/${raidGroupId}/raidGroupRequest`, {
requestMessage
});
try{
const response = await api.post(`/raidGroup/${raidGroupId}/raidGroupRequest`, {requestMessage});
if(response.status !== 200){
throw new Error("Failed to create raid group request");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidGroupRequest", raidGroupId] });
@@ -84,16 +104,21 @@ export function useResolveRaidGroupRequest(raidGroupId: string, raidGroupRequest
return useMutation({
mutationKey: ["raidGroupRequest", raidGroupId, raidGroupRequestId],
mutationFn: async (permission: RaidGroupPermissionType) => {
const response = await api.put(`/raidGroup/${raidGroupId}/raidGroupRequest/${raidGroupRequestId}/resolve`, {
resolution: permission
});
try{
const response = await api.put(`/raidGroup/${raidGroupId}/raidGroupRequest/${raidGroupRequestId}/resolve`, {resolution: permission});
if(response.status !== 200){
throw new Error("Failed to resolve raid group request");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidGroupRequest", raidGroupId] });
@@ -108,14 +133,21 @@ export function useDeleteRaidGroupRequest(raidGroupId: string, raidGroupRequestI
return useMutation({
mutationKey: ["raidGroupRequest", raidGroupId, raidGroupRequestId],
mutationFn: async () => {
try{
const response = await api.delete(`/raidGroup/${raidGroupId}/raidGroupRequest/${raidGroupRequestId}`);
if(response.status !== 200){
throw new Error("Failed to delete raid group request");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidGroupRequest", raidGroupId] });

138
src/hooks/RaidInstanceHooks.ts
View File

@@ -2,22 +2,30 @@ import { RaidInstance } from "@/interface/RaidInstance";
import { RaidInstancePersonCharacterXref } from "@/interface/RaidInstancePersonCharacterXref";
import { api } from "@/util/AxiosUtil";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AxiosError } from "axios";
export function useGetRaidInstance(raidInstanceId: string, raidGroupId: string){
return useQuery({
queryKey: ["raidInstances", raidInstanceId, raidGroupId],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/raidInstance/${raidInstanceId}`);
if(response.status !== 200){
throw new Error("Failed to get raid instance");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as RaidInstance;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!raidInstanceId && !!raidGroupId
});
@@ -34,17 +42,24 @@ export function useGetRaidInstancesByRaidGroup(raidGroupId: string, page: number
params.append("searchTerm", searchTerm);
}
try{
const response = await api.get(`/raidGroup/${raidGroupId}/raidInstance?${params}`);
if(response.status !== 200){
throw new Error("Failed to get accounts");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as RaidInstance[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -58,17 +73,24 @@ export function useGetRaidInstancesByRaidGroupCount(raidGroupId: string, searchT
params.append("searchTerm", searchTerm);
}
try{
const response = await api.get(`/raidGroup/${raidGroupId}/raidInstance/count?${params}`);
if(response.status !== 200){
throw new Error("Failed to get accounts");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -80,17 +102,23 @@ export function useCreateRaidInstance(raidGroupId: string){
return useMutation({
mutationKey: ["createRaidInstance", raidGroupId],
mutationFn: async (raidInstance: RaidInstance) => {
console.log("raidInstance2", raidInstance);
try{
const response = await api.post(`/raidGroup/${raidGroupId}/raidInstance`, raidInstance);
if(response.status !== 200){
throw new Error("Failed to create raid instance");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.raidInstanceId as string;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidInstances"] });
@@ -105,14 +133,21 @@ export function useUpdateRaidInstance(raidGroupId: string){
return useMutation({
mutationKey: ["updateRaidInstance", raidGroupId],
mutationFn: async (raidInstance: RaidInstance) => {
try{
const response = await api.put(`/raidGroup/${raidGroupId}/raidInstance/${raidInstance.raidInstanceId}`, raidInstance);
if(response.status !== 200){
throw new Error("Failed to update raid instance");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidInstances"] });
@@ -124,15 +159,22 @@ export function useUpdateRaidInstanceNoInvalidation(raidGroupId: string){
return useMutation({
mutationKey: ["updateRaidInstance", raidGroupId],
mutationFn: async (raidInstance: RaidInstance) => {
try{
const response = await api.put(`/raidGroup/${raidGroupId}/raidInstance/${raidInstance.raidInstanceId}`, raidInstance);
if(response.status !== 200){
throw new Error("Failed to update raid instance");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -143,14 +185,21 @@ export function useDeleteRaidInstance(raidGroupId: string, raidInstanceId: strin
return useMutation({
mutationKey: ["deleteRaidInstance", raidGroupId, raidInstanceId],
mutationFn: async () => {
try{
const response = await api.delete(`/raidGroup/${raidGroupId}/raidInstance/${raidInstanceId}`);
if(response.status !== 200){
throw new Error("Failed to delete raid instance");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidInstances"] });
@@ -163,16 +212,23 @@ export function useGetRaidInstancePersonCharacterXrefs(raidGroupId?: string, rai
return useQuery({
queryKey: ["raidInstancePersonCharacterXrefs", raidGroupId, raidInstanceId],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/raidInstance/${raidInstanceId}/personCharacterXref`);
if(response.status !== 200){
throw new Error("Failed to get raid instance person character xrefs");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as RaidInstancePersonCharacterXref[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!raidGroupId && !!raidInstanceId
});
@@ -185,18 +241,24 @@ export function useUpdateRaidInstancePersonCharacterXrefs(raidGroupId?: string,
return useMutation({
mutationKey: ["updateRaidInstancePersonCharacterXrefs", raidGroupId, raidInstanceId],
mutationFn: async (raidInstancePersonCharacterXrefs: RaidInstancePersonCharacterXref[]) => {
try{
const response = await api.post(`/raidGroup/${raidGroupId}/raidInstance/${raidInstanceId}/personCharacterXref`, raidInstancePersonCharacterXrefs);
if(response.status !== 200){
throw new Error("Failed to update raid instance person character xrefs");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidInstancePersonCharacterXrefs", raidGroupId, raidInstanceId] });
}
});
}

91
src/hooks/RaidLayoutHooks.ts
View File

@@ -1,22 +1,30 @@
import { RaidLayout, RaidLayoutClassGroupXref } from "@/interface/RaidLayout";
import { api } from "@/util/AxiosUtil";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AxiosError } from "axios";
export function useGetRaidLayout(raidGroupId?: string, raidLayoutId?: string){
return useQuery({
queryKey: ["raidLayout", raidGroupId, raidLayoutId],
queryFn: async () => {
try{
const response = await api.get(`/raidGroup/${raidGroupId}/raidLayout/${raidLayoutId}`);
if(response.status !== 200){
throw new Error("Failed to get raid layout");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as RaidLayout;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
enabled: !!raidGroupId && !!raidLayoutId
});
@@ -33,17 +41,24 @@ export function useGetRaidLayoutsByRaidGroup(raidGroupId: string, page: number,
params.append("searchTerm", searchTerm);
}
try{
const response = await api.get(`/raidGroup/${raidGroupId}/raidLayout?${params}`);
if(response.status !== 200){
throw new Error("Failed to get accounts");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data as RaidLayout[];
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -56,17 +71,24 @@ export function useGetRaidLayoutsByRaidGroupCount(raidGroupId: string, searchTer
params.append("searchTerm", searchTerm);
}
try{
const response = await api.get(`/raidGroup/${raidGroupId}/raidLayout/count?${params}`);
if(response.status !== 200){
throw new Error("Failed to get accounts");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
return response.data.count as number;
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
}
});
}
@@ -77,6 +99,7 @@ export function useCreateRaidLayout(raidGroupId: string){
return useMutation({
mutationKey: ["createRaidLayout", raidGroupId],
mutationFn: async ({raidLayout, raidLayoutClassGroupXrefs}:{raidLayout: RaidLayout; raidLayoutClassGroupXrefs: RaidLayoutClassGroupXref[];}) => {
try{
const response = await api.post(`/raidGroup/${raidGroupId}/raidLayout`,
{
raidLayout,
@@ -84,12 +107,18 @@ export function useCreateRaidLayout(raidGroupId: string){
}
);
if(response.status !== 200){
throw new Error("Failed to create raid layout");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidLayouts", raidGroupId] });
@@ -104,6 +133,7 @@ export function useUpdateRaidLayout(raidGroupId: string){
return useMutation({
mutationKey: ["updateRaidLayout", raidGroupId],
mutationFn: async ({raidLayout, raidLayoutClassGroupXrefs}:{raidLayout: RaidLayout; raidLayoutClassGroupXrefs: RaidLayoutClassGroupXref[];}) => {
try{
const response = await api.put(`/raidGroup/${raidGroupId}/raidLayout/${raidLayout.raidLayoutId}`,
{
raidLayout,
@@ -111,12 +141,18 @@ export function useUpdateRaidLayout(raidGroupId: string){
}
);
if(response.status !== 200){
throw new Error("Failed to update raid layout");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidLayouts", raidGroupId] });
@@ -132,14 +168,21 @@ export function useDeleteRaidLayout(raidGroupId: string, raidLayoutId: string){
return useMutation({
mutationKey: ["deleteRaidLayout", raidGroupId, raidLayoutId],
mutationFn: async () => {
try{
const response = await api.delete(`/raidGroup/${raidGroupId}/raidLayout/${raidLayoutId}`);
if(response.status !== 200){
throw new Error("Failed to delete raid layout");
}
else if(response.data.errors){
if(response.data.errors){
throw new Error(response.data.errors.join(", "));
}
}
catch(error){
if(error instanceof AxiosError && error.response?.data.errors){
throw new Error(error.response?.data.errors.join(", "));
}
else{
throw error;
}
}
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["raidLayouts", raidGroupId] });