stay_commerce-frontend 0.1.0

data/app/javascript/react/redux/slices/PropertySlice/PropertySlice.jsx

@@ -0,0 +1,722 @@
+import { createSlice, createAsyncThunk } from "@reduxjs/toolkit";
+import API from "../../../utils/helpers/APIHelper";
+import { ENDPOINTS } from "../../../Api/apiConstants";
+import ErrorHandler from "../../../utils/helpers/ErrorHandler";
+import { PhilippinePesoIcon } from "lucide-react";
+PhilippinePesoIcon;
+
+export const createProperties = createAsyncThunk(
+  "property/createProperties",
+  async (payload, { rejectWithValue }) => {
+    try {
+      const token = localStorage.getItem("authToken");
+
+      if (!token) throw new Error("No authentication token found");
+      const response = await API.post(ENDPOINTS.CREATE_PROPERTIES, payload, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+        },
+      });
+
+      return response;
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+export const updateProperties = createAsyncThunk(
+  "property/updateProperties",
+  async (payload, { rejectWithValue }) => {
+    try {
+      const token = localStorage.getItem("authToken");
+      if (!token) throw new Error("No authentication token found");
+      const response = await API.put(
+        `${ENDPOINTS.UPDATE_PROPERTIES}/${payload?.property?.id}`,
+        payload.property,
+        {
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+          },
+        }
+      );
+
+      return response; // Return only the data if needed
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+export const getUserBookingsDetails = createAsyncThunk(
+  "properties/bookings",
+  async ({ page }, { rejectWithValue }) => {
+    try {
+      const response = await API.get(ENDPOINTS.GET_BOOKING_DEATAILS(page));
+      return response;
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error);
+    }
+  }
+);
+
+export const getHostBookingsDetails = createAsyncThunk(
+  "properties/hostBookings",
+  async ({ page }, { rejectWithValue }) => {
+    try {
+      const response = await API.get(ENDPOINTS.HOST_BOOKING_DETAILS(page));
+      return response;
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error);
+    }
+  }
+);
+
+export const uploadImageProperties = createAsyncThunk(
+  "property/uploadImageProperties",
+  async (formData, { rejectWithValue }) => {
+    try {
+      let propertyId = formData.get("property[id]");
+
+      if (!propertyId) {
+        propertyId = formData.get("id");
+      }
+
+      if (!propertyId) {
+        return rejectWithValue("Property ID is required");
+      }
+
+      const response = await API.put(
+        `${ENDPOINTS.UPDATE_PROPERTIES}/${propertyId}`,
+        formData,
+        {
+          headers: {
+            "Content-Type": "multipart/form-data",
+          },
+        }
+      );
+      return { ...response.data, success: true };
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+export const getallupdateProperties = createAsyncThunk(
+  "property/PropertyToEdit",
+  async (payload, { rejectWithValue }) => {
+    try {
+      const response = await API.get(
+        `${ENDPOINTS.GET_ALL_UPDATE_PROPERTY_DETAILS}/${payload?.propertyId}`
+      );
+      return response.property; // ✅ Return only the nested property
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+export const getPropertyCategories = createAsyncThunk(
+  "properties/propertiesCategories",
+  async (_, { rejectWithValue }) => {
+    try {
+      const token = localStorage.getItem("authToken");
+      if (!token) throw new Error("No authentication token found");
+      const response = await API.get(ENDPOINTS.PROPERTY_CATEGORY, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      });
+      return response.data;
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+export const getPropertyType = createAsyncThunk(
+  "properties/propertyTypes",
+  async (_, { rejectWithValue }) => {
+    try {
+      const token = localStorage.getItem("authToken");
+      if (!token) throw new Error("No authentication token found");
+      const response = await API.get(ENDPOINTS.GET_ALL_PROPERTY_TYPE, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      });
+      return response.data;
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+export const getCard = createAsyncThunk(
+  "payment/getCard",
+  async (_, { rejectWithValue }) => {
+    try {
+      const token = localStorage.getItem("authToken");
+      if (!token) throw new Error("No authentication token found");
+
+      const response = await fetch(
+        "http://localhost:5000/stay/api/v1/credit_cards",
+        {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+          },
+        }
+      );
+
+      const data = await response.json();
+      if (response.status === 422 && data?.error === "No credit cards found") {
+        return null;
+      }
+
+      if (!response.ok)
+        throw new Error(data.message || "Failed to fetch cards");
+
+      return data.data;
+    } catch (error) {
+      return rejectWithValue(error?.message || "An unexpected error occurred");
+    }
+  }
+);
+
+export const searchProperties = createAsyncThunk(
+  "properties/searchProperties",
+  async (searchQuery, { rejectWithValue }) => {
+    try {
+      const response = await API.get(ENDPOINTS.SEARCH_PROPERTIES(searchQuery));
+      return {
+        success: true,
+        data: response.data,
+      };
+    } catch (error) {
+      if (error.response && error.response.status === 404) {
+        toast.error(error.response.data.error || error.response.data.message, {
+          position: "top-right",
+        });
+        return rejectWithValue(error.response.data);
+      }
+      ErrorHandler(error);
+      return rejectWithValue(error.message);
+    }
+  }
+);
+
+export const getPaymentmethods = createAsyncThunk(
+  "payment/getCard",
+  async (_, thunkAPI) => {
+    try {
+      const token = localStorage.getItem("authToken");
+      const response = await fetch(
+        "http://localhost:5000/stay/api/v1/payments/payment_method",
+        {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+          },
+        }
+      );
+      const data = await response.json();
+      if (!response.ok) throw new Error(data.message);
+      return data.data;
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(
+        error.response?.data || error.message || "An error occurred"
+      );
+    }
+  }
+);
+
+export const deleteCard = createAsyncThunk(
+  "payment/deleteCard",
+  async (id, thunkAPI) => {
+    try {
+      const token = localStorage.getItem("authToken");
+      const response = await fetch(
+        `http://localhost:5000/stay/api/v1/credit_cards/${id}`,
+        {
+          method: "DELETE",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+          },
+          body: JSON.stringify({ credit_card: { id } }),
+        }
+      );
+      const data = await response.json();
+      if (!response.ok) throw new Error(data.message);
+      return id;
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(
+        error.response?.data || error.message || "An error occurred"
+      );
+    }
+  }
+);
+
+export const saveCard = createAsyncThunk(
+  "payment/saveCard",
+  async (cardDetails, thunkAPI) => {
+    try {
+      const token = localStorage.getItem("authToken");
+      const response = await fetch(
+        "http://localhost:5000/stay/api/v1/credit_cards",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+          },
+          body: JSON.stringify({
+            credit_card: {
+              cc_number: cardDetails.cc_number,
+              month: cardDetails.month,
+              year: cardDetails.year,
+              card_token: cardDetails.card_token,
+            },
+          }),
+        }
+      );
+      const data = await response.json();
+      if (!response.ok) throw new Error(data.message);
+      return data.data;
+    } catch (error) {
+      return thunkAPI.rejectWithValue(
+        error?.response?.data || error.message || "An error occurred"
+      );
+    }
+  }
+);
+
+export const createPayment = createAsyncThunk(
+  "payment/createPayment",
+  async ({ bookingId, paymentMethodId }, thunkAPI) => {
+    const token = localStorage.getItem("authToken");
+    const response = await fetch("http://localhost:5000/stay/api/v1/payments", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify({
+        booking_id: bookingId.toString(),
+        confirm: "true",
+        currency: "usd",
+        payment_method_id: paymentMethodId,
+      }),
+    });
+    const data = await response.json();
+    if (!response.ok) throw new Error(data.message);
+    return data;
+  }
+);
+
+export const confirmBooking = createAsyncThunk(
+  "booking/confirmBooking",
+  async ({ bookingId, paymentMethodId, amount }, thunkAPI) => {
+    const token = localStorage.getItem("authToken");
+    const response = await fetch(
+      `http://localhost:5000/stay/api/v1/bookings/${bookingId}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+          booking: {
+            status: "confirmed",
+            payments_attributes: [
+              {
+                payment_method_id: paymentMethodId,
+                amount: amount,
+                state: "paid",
+              },
+            ],
+          },
+        }),
+      }
+    );
+
+    const data = await response.json();
+    if (!response.ok)
+      throw new Error(data.message || "Failed to confirm booking");
+    return data;
+  }
+);
+
+export const getallPropertieslisting = createAsyncThunk(
+  "property/getAllPropertiesListing",
+  async (payload, { rejectWithValue }) => {
+    try {
+      const token = localStorage.getItem("authToken");
+      if (!token) throw new Error("No authentication token found");
+
+      // Build the URL with query parameters
+      let url = ENDPOINTS.GET_PROPERTY_Listing;
+
+      // Add query parameters
+      const queryParams = [];
+      if (payload?.page) {
+        queryParams.push(`page=${payload.page}`);
+      }
+      if (payload?.query) {
+        queryParams.push(`query=${encodeURIComponent(payload.query)}`);
+      }
+
+      // Append query parameters if they exist
+      if (queryParams.length > 0) {
+        url += `?${queryParams.join("&")}`;
+      }
+
+      const response = await API.get(url);
+      return response;
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+export const getAmenitiesProperty = createAsyncThunk(
+  "properties/amenitiesProperty",
+  async (_, { rejectWithValue }) => {
+    try {
+      const response = await API.get(ENDPOINTS.AMENITIES_PROPERTIES);
+      return response; // Adjust if your API wraps this in .data
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+export const getFeaturesProperty = createAsyncThunk(
+  "properties/featuresCategories",
+  async (_, { rejectWithValue }) => {
+    try {
+      const response = await API.get(ENDPOINTS.GET_ALL_FEATURES_STATUS);
+      return response; // Adjust if your API wraps this in .data
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+// GET: Room Amenities
+export const getRoomAmenitiesProperty = createAsyncThunk(
+  "properties/getRoomAmenitiesProperty",
+  async (_, { rejectWithValue }) => {
+    try {
+      const response = await API.get(ENDPOINTS.ROOM_AMENITIES_PROPERTIES);
+      return response;
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+// GET: Room Features
+export const getRoomFeaturesProperty = createAsyncThunk(
+  "properties/getRoomFeaturesProperty",
+  async (_, { rejectWithValue }) => {
+    try {
+      const response = await API.get(ENDPOINTS.ROOM_FEATURES_PROPERTIES);
+      return response;
+    } catch (error) {
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+// GET: Bed Type
+export const getBedType = createAsyncThunk(
+  "properties/getBedType",
+  async (_, { rejectWithValue }) => {
+    try {
+      const response = await API.get(ENDPOINTS.ROOM_BED_TYPE);
+      return response;
+    } catch (error) {
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+// GET: Room Type
+export const getRoomType = createAsyncThunk(
+  "properties/getRoomType",
+  async (_, { rejectWithValue }) => {
+    try {
+      const response = await API.get(ENDPOINTS.ROOM_TYPE);
+      return response;
+    } catch (error) {
+      return rejectWithValue(error.response?.data || error.message);
+    }
+  }
+);
+
+export const deleteImage = createAsyncThunk(
+  "properties/deleteImage",
+  async ({ id }, { rejectWithValue }) => {
+    try {
+      // The id parameter might be an array, but your endpoint expects a different format
+      const response = await API.delete(ENDPOINTS.DELETEIMAGE, {
+        data: { id },
+      });
+      return response;
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error);
+    }
+  }
+);
+
+export const reserveBooking = createAsyncThunk(
+  "payment/reserveBooking",
+  async (payload, { rejectWithValue }) => {
+    try {
+      const response = await API.post(ENDPOINTS.BOOKING, payload);
+      return response.data;
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error);
+    }
+  }
+);
+
+export const similar_Properties = createAsyncThunk(
+  "properties/similarProperties",
+  async (
+    { property_type_id, property_category_id, property_id },
+    { rejectWithValue }
+  ) => {
+    try {
+      const url = `${ENDPOINTS.SIMILAR_PROPERTIES}?property_type_id=${property_type_id}&property_category_id=${property_category_id}&property_id=${property_id}`;
+      const response = await API.get(url);
+      return response;
+    } catch (error) {
+      return rejectWithValue(error);
+    }
+  }
+);
+
+export const getAllProperties = createAsyncThunk(
+  "properties/allProperties",
+  async (page, { rejectWithValue }) => {
+    try {
+      const response = await API.get(ENDPOINTS.GET_ALL_PROPERTIES(page));
+      return response; // Returning data directly, which contains user info
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error);
+    }
+  }
+);
+export const getBookingDetails = createAsyncThunk(
+  "properties/bookings",
+  async (id, { rejectWithValue }) => {
+    try {
+      const response = await API.get(`${ENDPOINTS.BOOKING_DETAILS}/${id}`);
+      return response; // Returning data directly, which contains user info
+    } catch (error) {
+      ErrorHandler(error);
+      return rejectWithValue(error);
+    }
+  }
+);
+
+const initialState = {
+  property: null,
+  globalId: null,
+  propertyToCreate: {},
+  allProperties: [],
+  metaData: {},
+  searchedData: {},
+  PropertyToEdit: null,
+  propertiesCategories: [],
+  propertyTypes: [],
+  amenities: [],
+  featureCategories: [],
+  roomamenitiesCategories: [],
+  roomfeaturesCategories: [],
+  bedType: [],
+  roomType: [],
+  loading: false,
+};
+
+const propertiesSlice = createSlice({
+  name: "properties",
+  initialState,
+  reducers: {
+    setId: (state, action) => {
+      state.globalId = action.payload;
+    },
+    setPropertyToCreate: (state, action) => {
+      state.propertyToCreate = action.payload;
+    },
+    setProperties: (state, action) => {
+      state.allProperties = action.payload;
+    },
+    clearPropertyToEdit: (state) => {
+      state.PropertyToEdit = null;
+    },
+    setSearchData: (state, action) => {
+      const {
+        startDate,
+        endDate,
+        totalGuests,
+        latitude,
+        longitude,
+        label,
+        locationData,
+        searchedResult,
+      } = action.payload;
+      state.searchedData = {
+        ...state.searchedData,
+        startDate,
+        endDate,
+        totalGuests,
+        latitude,
+        longitude,
+        label,
+        locationData,
+        searchedResult,
+      };
+    },
+  },
+  extraReducers: (builder) => {
+    builder
+
+      .addCase(createProperties.fulfilled, (state, action) => {
+        state.loading = false;
+        state.property = action.payload;
+      })
+
+      .addCase(updateProperties.fulfilled, (state, action) => {
+        state.loading = false;
+        state.property = action.payload;
+      })
+      .addCase(uploadImageProperties.fulfilled, (state, action) => {
+        state.loading = false;
+        state.property = action.payload;
+      })
+      .addCase(getallupdateProperties.fulfilled, (state, action) => {
+        state.PropertyToEdit = action.payload || null;
+        state.loading = false;
+      })
+      .addCase(getallPropertieslisting.fulfilled, (state, action) => {
+        const data = action.payload;
+        state.allProperties = data?.properties || [];
+        state.metaData = data?.meta || {};
+        state.loading = false;
+      })
+      .addCase(getPropertyCategories.fulfilled, (state, action) => {
+        // state.propertiesCategories = action.payload?.data || [];
+        state.propertiesCategories = action.payload;
+        state.loading = false;
+      })
+      .addCase(getPropertyType.fulfilled, (state, action) => {
+        // state.propertyTypes = action.payload?.data || [];
+        state.propertyTypes = action.payload;
+        state.loading = false;
+      })
+      .addCase(getAmenitiesProperty.fulfilled, (state, action) => {
+        state.amenities = action.payload?.data || [];
+        state.loading = false;
+      })
+      .addCase(getFeaturesProperty.fulfilled, (state, action) => {
+        state.featureCategories = action.payload?.data || [];
+        state.loading = false;
+      })
+      .addCase(getRoomAmenitiesProperty.fulfilled, (state, action) => {
+        state.roomamenitiesCategories = action.payload;
+        state.loading = false;
+      })
+      .addCase(getRoomFeaturesProperty.fulfilled, (state, action) => {
+        state.roomfeaturesCategories = action.payload;
+        state.loading = false;
+      })
+      .addCase(getBedType.fulfilled, (state, action) => {
+        state.bedType = action.payload;
+        state.loading = false;
+      })
+      .addCase(getRoomType.fulfilled, (state, action) => {
+        state.roomType = action.payload;
+        state.loading = false;
+      })
+      .addCase(getAllProperties.fulfilled, (state, action) => {
+        state.PropertyToEdit = action.payload || null;
+        state.loading = false;
+      })
+      .addMatcher(
+        (action) =>
+          [
+            createProperties.pending.type,
+            updateProperties.pending.type,
+            uploadImageProperties.pending.type,
+            getallupdateProperties.pending.type,
+            getallPropertieslisting.pending.type,
+            getPropertyCategories.pending.type,
+            getPropertyType.pending.type,
+            getAmenitiesProperty.pending.type,
+            getFeaturesProperty.pending.type,
+            getRoomAmenitiesProperty.pending.type,
+            getRoomFeaturesProperty.pending.type,
+            getBedType.pending.type,
+            getRoomType.pending.type,
+          ].includes(action.type),
+        (state) => {
+          state.loading = true;
+        }
+      )
+      .addMatcher(
+        (action) =>
+          [
+            createProperties.rejected.type,
+            updateProperties.rejected.type,
+            uploadImageProperties.rejected.type,
+            getallupdateProperties.rejected.type,
+            getallPropertieslisting.rejected.type,
+            getPropertyCategories.rejected.type,
+            getPropertyType.rejected.type,
+            getAmenitiesProperty.rejected.type,
+            getFeaturesProperty.rejected.type,
+            getRoomAmenitiesProperty.rejected.type,
+            getRoomFeaturesProperty.rejected.type,
+            getBedType.rejected.type,
+            getRoomType.rejected.type,
+          ].includes(action.type),
+        (state) => {
+          state.loading = false;
+        }
+      );
+  },
+});
+
+export const {
+  setId,
+  setProperties,
+  setPropertyToCreate,
+  setSearchData,
+  clearPropertyToEdit,
+} = propertiesSlice.actions;
+
+export default propertiesSlice.reducer;