create-gufran-expo-app 2.0.0 → 2.0.1

package/template/src/services/api.ts

@@ -0,0 +1,167 @@
+import axios from 'axios';
+import { MMKV } from 'react-native-mmkv';
+import { StorageService } from '../utils/storage';
+import { Platform } from 'react-native';
+import ToastManager from '../components/common/ToastManager';
+import { useAuthStore } from '../stores/authStore';
+
+// API Configuration
+export const API_BASE_URL = `${process.env.EXPO_PUBLIC_API_BASE_URL}/api/v1/`; // prod api url
+export const CHAT_HUB_URL = `${process.env.EXPO_PUBLIC_API_BASE_URL}/chathub`; // dev chat hub url
+
+// Create axios instance with default config
+const offsetTime = new Date().getTimezoneOffset() * 60 * -1;
+
+// MMKV default storage (NotificationManager saves fcmToken here)
+const mmkvDefaultStorage = new MMKV();
+
+// Helpers to manage the FCM device token within this module
+export const setFCMDeviceToken = (token: string): void => {
+  try {
+    if (token) {
+      mmkvDefaultStorage.set('fcmToken', token);
+    }
+  } catch { }
+};
+
+export const getFCMDeviceToken = (): string | undefined => {
+  try {
+    const token = mmkvDefaultStorage.getString('fcmToken');
+    return token || undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+export const apiClient = axios.create({
+  baseURL: API_BASE_URL,
+  timeout: 10000,
+  headers: {
+    'Content-Type': 'application/json',
+    UtcOffsetInSecond: offsetTime,
+    AppVersion: 1,
+    DeviceTypeId: Platform.OS == "android" ? 1 : 2,
+    DeviceToken: ""
+  },
+});
+
+// Request interceptor to add auth tokens
+apiClient.interceptors.request.use(
+  (config) => {
+    // Add auth tokens if available
+    const tokens = StorageService.auth.getTokens();
+    if (tokens.accessToken) {
+      config.headers.AccessToken = tokens.accessToken;
+    }
+    if (tokens.authorizationToken) {
+      config.headers.Authorization = "Bearer " + tokens.authorizationToken;
+    }
+
+    // Add FCM DeviceToken header if available
+    try {
+      const fcmToken = mmkvDefaultStorage.getString('fcmToken');
+      if (fcmToken) {
+        config.headers.DeviceToken = fcmToken;
+      }
+    } catch { }
+
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+
+// Response interceptor for error handling
+apiClient.interceptors.response.use(
+  (response) => {
+    return response;
+  },
+  (error) => {
+    console.log('Error response status:', error.response?.data);
+    if (error.response?.status === 401) {
+      clearAuthTokens();
+      ToastManager.error(error.response?.data?.message);
+    }
+    // Handle 409 status code differently - don't treat it as an error flow
+    if (error.response?.status === 409) {
+      // Return the response so it can be handled as a successful response with special status
+      return Promise.resolve({
+        data: error.response.data,
+        status: error.response.status,
+        statusText: error.response.statusText,
+        headers: error.response.headers,
+        config: error.config
+      });
+    }
+    return Promise.reject(error);
+  }
+);
+
+const clearAuthTokens = (): void => {
+  StorageService.auth.clearAuthData();
+  useAuthStore.getState().logout();
+};
+
+// API Endpoints
+export const API_ENDPOINTS = {
+  AUTH: {
+    LOGIN: 'Account/Login',
+    REGISTER: 'Account/SignUp',
+    FORGOT_PASSWORD: 'Account/ForgetPassword',
+    REFRESH_TOKEN: 'auth/refresh-token',
+    UPLOAD_SAS: 'Upload/SasToken',
+    VERIFY_OTP: 'Account/Verifyotp',
+    RESEND_OTP: 'Account/ResendOtp',
+    LOGOUT: 'Account/Logout',
+
+  },
+  VOLUNTEER: {
+    HOURS_DETAILS: 'Volunteer/Opportunities/GetVolunteerHoursDetails',
+    OPPORTUNITIES: 'Volunteer/Opportunities',
+    OPPORTUNITIES_BY_ID: 'Volunteer/Opportunities/{opportunityId}',
+    OPPORTUNITY_VOLUNTEERS: 'Volunteer/Opportunities/Volunteers',
+    JOIN: 'Volunteer/Opportunities/Join',
+    CANCEL_REQUEST: 'Volunteer/Opportunities/CancelVolunteerRequest',
+    SLOTS_BY_OPPORTUNITY: 'Volunteer/Opportunities/GetSlotsByOpportunityId',
+    REMINDER: 'Volunteer/opportunity/Reminder',
+    GET_REMINDER: 'Volunteer/opportunity/{opportunityId}/reminder',
+    DELETE_REMINDER: 'Volunteer/opportunity/{opportunityId}/reminder/{reminderId}',
+    VOLUNTEER_CHAT: 'Volunteer/members/{memberId}/Threads/{threadId}/messages/{pageNumber}',
+  },
+  USER: {
+    MEMBERS: 'user/members',
+    UPDATE_MEMBER: 'user/members',
+  },
+  CLUB: {
+    SEARCH: 'club/search',
+    SEARCH_MY_CLUBS: 'club/myclubs',
+    JOIN: 'club/{clubId}/members/{memberId}/join',
+    MEMBERS: 'club/{clubId}/members',
+    ANNOUNCEMENTS: 'club/{clubId}/announcements',
+  },
+  UPLOAD: {
+    GET_IMAGE_URL: 'Upload/GetImageUrl',
+  },
+  PAYMENT: {
+    PROCESS: 'Payments',
+  },
+  RAFFLE: {
+    GET_REFEREE_CODE: 'GetRefereeCode',
+    VERIFY_REFERRAL_CODE: 'Raffles/Code/Verify',
+    REMINDER: 'Raffles/Reminder',
+    GET_REMINDER: 'Raffles/{raffleId}/Reminder',
+    DELETE_REMINDER: 'Raffles/Reminder/{reminderId}',
+    GET_TICKET_DETAILS: 'Raffles/referral-ticket-details',
+  },
+  TEAM: {
+    SERCH_JOIN_TEAMS: 'Teams/Club/{clubId}/Teams/search',
+    MY_TEAMS: 'MyTeam/{memberId}',
+    JOIN_TEAM: 'Teams/join',
+    PENDING_REQUEST: 'Teams/GetJoinedTeamPendingRequestList',
+    CANCEL_PENDING_REQUEST: 'MyTeam/Request/Cancle',
+    TEAM_DETAILS: 'Teams/{teamId}/Details',
+    TEAM_THREADS: 'Teams/{teamId}/member/{memberId}/Threads',
+    TEAM_CHAT: 'Teams/{teamId}/members/{memberId}/Threads/{threadId}/messages/{pageNumber}',
+  }
+} as const;

package/template/src/services/authService.ts

@@ -0,0 +1,422 @@
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { apiClient, API_ENDPOINTS } from '../services/api';
+import { User } from '../stores/authStore';
+
+// Types for API requests and responses
+export interface ApiResponse<T = any> {
+  data: T;
+  status: number;
+  statusText: string;
+  headers: any;
+}
+
+export interface LoginRequest {
+  email: string;
+  password: string;
+  device_type?: string;
+  device_id?: string;
+}
+
+export interface LoginResponse {
+  apiName: string;
+  data: {
+    Name: string;
+    accessToken: string;
+    authorizationToken: string;
+    email: string;
+    isProfileCompleted: boolean;
+    profileImage: string;
+    userId: number;
+    userType: number;
+    isAddMember?: boolean;
+  };
+  message: string;
+}
+
+export interface RegisterRequest {
+  email: string;
+  password: string;
+  profileImage: string;
+  name?: string;
+  phoneNumber?: string;
+  confirmPassword?: string;
+}
+
+export interface RegisterResponse {
+  success: boolean;
+  message: string;
+  data: {
+    user: User;
+    token: string;
+    refreshToken?: string;
+  };
+}
+
+export interface ForgotPasswordRequest {
+  email: string;
+}
+
+export interface ForgotPasswordResponse {
+  success: boolean;
+  message: string;
+}
+
+export interface VerifyOTPRequest {
+  email: string;
+  otp: string;
+  deviceToken: string;
+  deviceType: number;
+}
+
+export interface VerifyOTPResponse {
+  success: boolean;
+  message: string;
+  data: {
+    userId: number;
+    Name: string;
+    email: string;
+    profileImage: string;
+    authorizationToken: string;
+    accessToken: string;
+    userType: number;
+    isProfileCompleted: boolean;
+    isAddMember: boolean;
+    message: string;
+    apiName: string;
+  };
+}
+
+export interface ResendOTPRequest {
+  email: string;
+}
+
+export interface ResendOTPResponse {
+  success: boolean;
+  message: string;
+}
+
+export interface LogoutResponse {
+  success: boolean;
+  message: string;
+  apiName?: string;
+}
+
+export interface MembersRequest {
+  PageNumber: number;
+  PageSize: number;
+}
+
+
+export interface MembersResponse {
+  apiName: string;
+  data: {
+    members?: any[];
+    totalCount: number;
+    pageNumber: number;
+    pageSize: number;
+    totalPages: number;
+  };
+  message: string;
+  success: boolean;
+}
+
+export interface UpdateMemberRequest {
+  id?: number;
+  name: string;
+  profileImage: string;
+  birthDate: string;
+  relation: string;
+}
+
+export interface UpdateMemberResponse {
+  apiName: string;
+  data: any;
+  message: string;
+  success: boolean;
+}
+
+export interface ClubSearchRequest {
+  pageNumber: number;
+  pageSize: number;
+}
+
+export interface ClubSearchResponse {
+  apiName: string;
+  data:any[];
+  message: string;
+  success: boolean;
+}
+
+export interface GetImageUrlRequest {
+  containerName: string;
+  blobName: string;
+}
+
+export interface GetImageUrlResponse {
+  apiName: string;
+  data: {
+    imageUrl: string;
+    url: string;
+  };
+  message: string;
+  success: boolean;
+}
+
+// API service functions
+export const authService = {
+  login: async (credentials: LoginRequest): Promise<ApiResponse<LoginResponse>> => {
+    const response = await apiClient.post(API_ENDPOINTS.AUTH.LOGIN, credentials);
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+  },
+
+  register: async (userData: RegisterRequest): Promise<ApiResponse<RegisterResponse>> => {
+    const response = await apiClient.post(API_ENDPOINTS.AUTH.REGISTER, userData);
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+  },
+
+  forgotPassword: async (email: ForgotPasswordRequest): Promise<ApiResponse<ForgotPasswordResponse>> => {
+    const response = await apiClient.post(API_ENDPOINTS.AUTH.FORGOT_PASSWORD, email);
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+  },
+
+  verifyOTP: async (otp: VerifyOTPRequest): Promise<ApiResponse<VerifyOTPResponse>> => {
+    const response = await apiClient.post(API_ENDPOINTS.AUTH.VERIFY_OTP, otp);
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+  },
+  
+  resendOTP: async (email: ResendOTPRequest): Promise<ApiResponse<ResendOTPResponse>> => {
+    const response = await apiClient.post(API_ENDPOINTS.AUTH.RESEND_OTP, email);
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+  },
+
+  logout: async (): Promise<ApiResponse<LogoutResponse>> => {
+    const response = await apiClient.post(API_ENDPOINTS.AUTH.LOGOUT);
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+  },
+
+  getMembers: async (params: MembersRequest): Promise<ApiResponse<MembersResponse>> => {
+    const response = await apiClient.get(API_ENDPOINTS.USER.MEMBERS, {
+      params: params,
+    });
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+  },
+
+  updateMember: async (memberId: number, memberData: UpdateMemberRequest): Promise<ApiResponse<UpdateMemberResponse>> => {
+    const response = await apiClient.post(`${API_ENDPOINTS.USER.UPDATE_MEMBER}/${memberId}`, memberData);
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+  },
+
+  searchClubs: async (params: ClubSearchRequest): Promise<ApiResponse<ClubSearchResponse>> => {
+    const response = await apiClient.get(API_ENDPOINTS.CLUB.SEARCH, {
+      params: params,
+    });
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+  },
+
+  getImageUrl: async (params: GetImageUrlRequest): Promise<ApiResponse<GetImageUrlResponse>> => {
+    const response = await apiClient.post(API_ENDPOINTS.UPLOAD.GET_IMAGE_URL, params);
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+  },
+};
+
+// Error handling utility
+export const getApiErrorInfo = (error: any) => {
+  const statusCode = error?.response?.status || error?.status || 0;
+  const statusText = error?.response?.statusText || error?.statusText || 'Unknown Error';
+  const message = error?.response?.data?.message || error?.message || 'An error occurred';
+  
+  return {
+    statusCode,
+    statusText,
+    message,
+    isNetworkError: !error?.response,
+    isServerError: statusCode >= 500,
+    isClientError: statusCode >= 400 && statusCode < 500,
+    isUnauthorized: statusCode === 401,
+    isForbidden: statusCode === 403,
+    isNotFound: statusCode === 404,
+    isValidationError: statusCode === 422,
+  };
+};
+
+// React Query hooks for authentication
+export const useLogin = () => {
+  return useMutation({
+    mutationFn: authService.login,
+    onSuccess: (response) => {
+      // Handle successful login
+      console.log('Login successful:', response);
+    },
+    onError: (error) => {
+      return error;
+    },
+  });
+};
+
+export const useRegister = () => {
+  return useMutation({
+    mutationFn: authService.register,
+    onSuccess: (response) => {
+      // Handle successful registration
+      console.log('Registration successful:', response.data);
+    },
+    onError: (error) => {
+      // Handle registration error with status code
+      const errorInfo = getApiErrorInfo(error);
+      console.error('Registration failed:', errorInfo);
+    },
+  });
+};
+
+export const useForgotPassword = () => {
+  return useMutation({
+    mutationFn: authService.forgotPassword,
+    onSuccess: (response) => {
+      // Handle successful forgot password request
+      console.log('Forgot password request successful:', response.data);
+    },
+    onError: (error) => {
+      // Handle forgot password error with status code
+      const errorInfo = getApiErrorInfo(error);
+      console.error('Forgot password request failed:', errorInfo);
+    },
+  });
+};
+
+export const useVerifyOTP = () => {
+  return useMutation({
+    mutationFn: authService.verifyOTP,
+    onSuccess: (response) => {
+      // Handle successful OTP verification
+      console.log('Verify OTP request successful:', response.data);
+    },
+    onError: (error) => {
+      // Handle OTP verification error with status code
+      const errorInfo = getApiErrorInfo(error);
+      console.error('Verify OTP request failed:', errorInfo);
+    },
+  });
+};
+
+export const useResendOTP = () => {
+  return useMutation({
+    mutationFn: authService.resendOTP,
+    onSuccess: (response) => {
+      console.log('Resend OTP request successful:', response.data);
+    },
+    onError: (error) => {
+      // Handle resend OTP error with status code
+      const errorInfo = getApiErrorInfo(error);
+      console.error('Resend OTP request failed:', errorInfo);
+    },
+  });
+};
+
+export const useLogout = () => {
+  return useMutation({
+    mutationFn: authService.logout,
+    onSuccess: (response) => {
+      console.log('Logout request successful:', response.data);
+    },
+    onError: (error) => {
+      // Handle logout error with status code
+      const errorInfo = getApiErrorInfo(error);
+      console.error('Logout request failed:', errorInfo);
+    },
+  });
+};
+
+export const useMembers = (params: MembersRequest) => {
+  return useQuery({
+    queryKey: ['members'],
+    queryFn: () => authService.getMembers(params),
+  });
+};
+
+export const useUpdateMember = () => {
+  return useMutation({
+    mutationFn: ({ memberId, memberData }: { memberId: number; memberData: UpdateMemberRequest }) => 
+      authService.updateMember(memberId, memberData),
+    onSuccess: (response) => {
+      console.log('Member update successful:', response.data);
+    },
+    onError: (error) => {
+      // Handle member update error with status code
+      const errorInfo = getApiErrorInfo(error);
+      console.error('Member update failed:', errorInfo);
+    },
+  });
+};
+
+export const useClubSearch = (params: ClubSearchRequest) => {
+  return useQuery({
+    queryKey: ['clubSearch', params],
+    queryFn: () => authService.searchClubs(params),
+  });
+};
+
+export const useGetImageUrl = () => {
+  return useMutation({
+    mutationFn: authService.getImageUrl,
+    onSuccess: (response) => {
+      console.log('Get image URL successful:', response.data);
+    },
+    onError: (error) => {
+      const errorInfo = getApiErrorInfo(error);
+      console.error('Get image URL failed:', errorInfo);
+    },
+  });
+};
+
+
+

package/template/src/services/index.ts

@@ -0,0 +1,5 @@
+// API Configuration
+export * from './api';
+
+// Auth Service
+export * from './authService';