@webbycrown/webbycommerce 1.2.1 → 2.0.0

package/server/src/services/compare.js

@@ -0,0 +1,300 @@
+'use strict';
+
+/**
+ * compare service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('plugin::webbycommerce.compare', ({ strapi }) => ({
+  async findUserCompare(userId) {
+    try {
+      const compares = await strapi.db.query('plugin::webbycommerce.compare').findMany({
+        where: {
+          userId: String(userId),
+        },
+        orderBy: { createdAt: 'desc' },
+        populate: {
+          products: {
+            populate: {
+              images: true,
+              product_categories: true,
+              tags: true,
+              variations: {
+                populate: {
+                  attributes: true,
+                  attributeValues: true,
+                },
+              },
+            },
+          },
+          category: true,
+        },
+      });
+
+      return compares.length > 0 ? compares[0] : null;
+    } catch (error) {
+      throw new Error(`Failed to find user compare: ${error.message}`);
+    }
+  },
+
+  async createUserCompare(userId, userEmail, data = {}) {
+    try {
+      const compareData = {
+        userId: String(userId),
+        userEmail,
+        products: [],
+        isPublic: data.isPublic || false,
+        name: data.name || null,
+        notes: data.notes || null,
+        category: data.categoryId || null,
+      };
+
+      await strapi.entityService.create('plugin::webbycommerce.compare', {
+        data: compareData,
+      });
+
+      // Refetch compare with populated products
+      return await this.findUserCompare(userId);
+    } catch (error) {
+      throw new Error(`Failed to create user compare: ${error.message}`);
+    }
+  },
+
+  async addProductToCompare(userId, userEmail, productId) {
+    try {
+      // Find existing compare or create new one
+      let compare = await this.findUserCompare(userId);
+
+      if (!compare) {
+        compare = await this.createUserCompare(userId, userEmail);
+      }
+
+      // Ensure products array exists
+      if (!compare.products) {
+        compare.products = [];
+      }
+
+      // Check if compare list is already full (max 4 products)
+      if (compare.products.length >= 4) {
+        throw new Error('Compare list is full. Maximum 4 products allowed.');
+      }
+
+      // Check if product already exists in compare
+      // Handle both populated (object with id) and unpopulated (just id) cases
+      const productExists = compare.products.some(product => {
+        const productIdValue = typeof product === 'object' && product !== null ? product.id : product;
+        return productIdValue === parseInt(productId);
+      });
+
+      if (productExists) {
+        throw new Error('Product already exists in compare list');
+      }
+
+      // Verify product exists
+      const product = await strapi.entityService.findOne('plugin::webbycommerce.product', productId, {
+        populate: ['product_categories'],
+      });
+
+      if (!product) {
+        throw new Error('Product not found');
+      }
+
+      // Check if product belongs to same category (optional but recommended)
+      if (compare.category && product.product_categories && product.product_categories.length > 0 && compare.category.id !== product.product_categories[0].id) {
+        // Allow but log warning - user can compare different categories if they want
+        strapi.log.warn(`Adding product from different category to compare list. Compare category: ${compare.category.name}, Product category: ${product.product_categories[0].name}`);
+      }
+
+      // Get existing product IDs (handle both populated and unpopulated cases)
+      const existingProductIds = compare.products.map(p => {
+        return typeof p === 'object' && p !== null ? p.id : p;
+      }).filter(id => id != null);
+
+      // Add product to compare
+      await strapi.entityService.update('plugin::webbycommerce.compare', compare.id, {
+        data: {
+          products: { set: [...existingProductIds, parseInt(productId, 10)].map((id) => ({ id })) },
+          category: compare.category || product.product_categories?.[0]?.id || null,
+        },
+      });
+
+      // Refetch compare with populated products
+      return await this.findUserCompare(userId);
+    } catch (error) {
+      throw new Error(`Failed to add product to compare: ${error.message}`);
+    }
+  },
+
+  async removeProductFromCompare(userId, productId) {
+    try {
+      const compare = await this.findUserCompare(userId);
+
+      if (!compare) {
+        throw new Error('Compare list not found');
+      }
+
+      // Ensure products array exists
+      if (!compare.products) {
+        compare.products = [];
+      }
+
+      // Remove product from compare
+      // Handle both populated (object with id) and unpopulated (just id) cases
+      const updatedProducts = compare.products
+        .filter(product => {
+          const productIdValue = typeof product === 'object' && product !== null ? product.id : product;
+          return productIdValue !== parseInt(productId);
+        })
+        .map(product => {
+          return typeof product === 'object' && product !== null ? product.id : product;
+        });
+
+      await strapi.entityService.update('plugin::webbycommerce.compare', compare.id, {
+        data: {
+          products: { set: updatedProducts.map((id) => ({ id })) },
+          // Reset category if no products left
+          category: updatedProducts.length === 0 ? null : compare.category,
+        },
+      });
+
+      // Refetch compare with populated products
+      return await this.findUserCompare(userId);
+    } catch (error) {
+      throw new Error(`Failed to remove product from compare: ${error.message}`);
+    }
+  },
+
+  async clearCompare(userId) {
+    try {
+      const compare = await this.findUserCompare(userId);
+
+      if (!compare) {
+        throw new Error('Compare list not found');
+      }
+
+      await strapi.entityService.update('plugin::webbycommerce.compare', compare.id, {
+        data: {
+          products: { set: [] },
+          category: null,
+        },
+      });
+
+      // Refetch compare with populated products
+      return await this.findUserCompare(userId);
+    } catch (error) {
+      throw new Error(`Failed to clear compare list: ${error.message}`);
+    }
+  },
+
+  async updateCompare(userId, data) {
+    try {
+      const compare = await this.findUserCompare(userId);
+
+      if (!compare) {
+        throw new Error('Compare list not found');
+      }
+
+      await strapi.entityService.update('plugin::webbycommerce.compare', compare.id, {
+        data: {
+          name: data.name !== undefined ? data.name : compare.name,
+          notes: data.notes !== undefined ? data.notes : compare.notes,
+          isPublic: data.isPublic !== undefined ? data.isPublic : compare.isPublic,
+        },
+      });
+
+      // Refetch compare with populated products
+      return await this.findUserCompare(userId);
+    } catch (error) {
+      throw new Error(`Failed to update compare list: ${error.message}`);
+    }
+  },
+
+  async getCompareData(userId) {
+    try {
+      const compare = await this.findUserCompare(userId);
+
+      if (!compare) {
+        return {
+          products: [],
+          category: null,
+          comparisonData: {},
+        };
+      }
+
+      // Ensure products array exists
+      if (!compare.products) {
+        compare.products = [];
+      }
+
+      // Generate comparison data
+      const comparisonData = this.generateComparisonData(compare.products);
+
+      return {
+        products: compare.products,
+        category: compare.category,
+        comparisonData,
+      };
+    } catch (error) {
+      throw new Error(`Failed to get compare data: ${error.message}`);
+    }
+  },
+
+  generateComparisonData(products) {
+    if (!products || products.length === 0) {
+      return {};
+    }
+
+    const comparisonData = {
+      specifications: {},
+      pricing: {},
+      availability: {},
+      ratings: {},
+    };
+
+    // Extract common specifications
+    const specKeys = new Set();
+    products.forEach(product => {
+      if (product.specifications) {
+        Object.keys(product.specifications).forEach(key => specKeys.add(key));
+      }
+    });
+
+    // Build comparison matrix
+    specKeys.forEach(specKey => {
+      comparisonData.specifications[specKey] = {};
+      products.forEach(product => {
+        comparisonData.specifications[specKey][product.id] =
+          product.specifications?.[specKey] || 'N/A';
+      });
+    });
+
+    // Pricing comparison
+    products.forEach(product => {
+      comparisonData.pricing[product.id] = {
+        regularPrice: product.regularPrice || 0,
+        salePrice: product.salePrice || null,
+        discount: product.discount || 0,
+      };
+    });
+
+    // Availability comparison
+    products.forEach(product => {
+      comparisonData.availability[product.id] = {
+        inStock: product.stockQuantity > 0,
+        stockQuantity: product.stockQuantity || 0,
+        status: product.status || 'active',
+      };
+    });
+
+    // Ratings comparison
+    products.forEach(product => {
+      comparisonData.ratings[product.id] = {
+        averageRating: product.averageRating || 0,
+        totalReviews: product.totalReviews || 0,
+      };
+    });
+
+    return comparisonData;
+  },
+}));

package/server/src/services/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const service = require('./service');
+const compare = require('./compare');
+const cart = require('./cart');
+const wishlist = require('./wishlist');
+const shipping = require('./shipping');
+
+module.exports = {
+  service,
+  compare,
+  cart,
+  wishlist,
+  shipping,
+};
+

package/server/src/services/service.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const PLUGIN_ID = 'webbycommerce';
+
+const { seedDemoData } = require('../utils/seed-data');
+
+module.exports = ({ strapi }) => ({
+  getPluginInfo() {
+    return {
+      name: PLUGIN_ID,
+      version: '1.0.0',
+    };
+  },
+
+  async seedDemoData() {
+    return await seedDemoData(strapi);
+  }
+});
+