@webbycrown/webbycommerce 1.2.1 → 2.0.0

package/server/src/content-types/shipping-rate/schema.json

@@ -0,0 +1,73 @@
+{
+  "kind": "collectionType",
+  "collectionName": "shipping_rates",
+  "info": {
+    "singularName": "shipping-rate",
+    "pluralName": "shipping-rates",
+    "displayName": "Shipping Rate",
+    "description": "Shipping rates based on weight, price, or quantity"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {
+    "content-manager": {
+      "visible": true
+    },
+    "content-api": {
+      "visible": true
+    }
+  },
+  "attributes": {
+    "name": {
+      "type": "string",
+      "required": true,
+      "description": "Rate name for admin reference"
+    },
+    "condition_type": {
+      "type": "enumeration",
+      "enum": ["weight", "price", "quantity", "volume", "dimension"],
+      "required": true,
+      "description": "What the rate is based on"
+    },
+    "min_value": {
+      "type": "decimal",
+      "required": true,
+      "min": 0,
+      "description": "Minimum value for this rate tier"
+    },
+    "max_value": {
+      "type": "decimal",
+      "required": false,
+      "min": 0,
+      "description": "Maximum value for this rate tier (null for unlimited)"
+    },
+    "rate": {
+      "type": "decimal",
+      "required": true,
+      "min": 0,
+      "description": "Shipping cost for this tier"
+    },
+    "currency": {
+      "type": "string",
+      "required": true,
+      "default": "USD"
+    },
+    "shippingMethod": {
+      "type": "relation",
+      "relation": "manyToOne",
+      "target": "plugin::webbycommerce.shipping-method",
+      "required": false
+    },
+    "is_active": {
+      "type": "boolean",
+      "default": true,
+      "required": true
+    },
+    "sort_order": {
+      "type": "integer",
+      "default": 0,
+      "required": false
+    }
+  }
+}

package/server/src/content-types/shipping-rule/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const schema = require('./schema.json');
+
+module.exports = {
+  schema,
+};

package/server/src/content-types/shipping-rule/schema.json

@@ -0,0 +1,84 @@
+{
+  "kind": "collectionType",
+  "collectionName": "shipping_rules",
+  "info": {
+    "singularName": "shipping-rule",
+    "pluralName": "shipping-rules",
+    "displayName": "Shipping Rule",
+    "description": "Rules and conditions for shipping eligibility"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {
+    "content-manager": {
+      "visible": true
+    },
+    "content-api": {
+      "visible": true
+    }
+  },
+  "attributes": {
+    "name": {
+      "type": "string",
+      "required": true
+    },
+    "description": {
+      "type": "text",
+      "required": false
+    },
+    "rule_type": {
+      "type": "enumeration",
+      "enum": ["restriction", "surcharge", "discount", "requirement"],
+      "required": true
+    },
+    "condition_type": {
+      "type": "enumeration",
+      "enum": ["product_category", "product_tag", "product_weight", "order_total", "customer_group", "shipping_address", "cart_quantity"],
+      "required": true
+    },
+    "condition_operator": {
+      "type": "enumeration",
+      "enum": ["equals", "not_equals", "greater_than", "less_than", "contains", "not_contains", "in", "not_in"],
+      "required": true
+    },
+    "condition_value": {
+      "type": "json",
+      "required": true,
+      "description": "Value(s) to compare against (string, number, or array)"
+    },
+    "action_type": {
+      "type": "enumeration",
+      "enum": ["hide_method", "add_fee", "subtract_fee", "set_rate", "multiply_rate"],
+      "required": true
+    },
+    "action_value": {
+      "type": "decimal",
+      "required": false,
+      "description": "Value for the action (fee amount, multiplier, etc.)"
+    },
+    "action_message": {
+      "type": "string",
+      "required": false,
+      "description": "Message to display when rule applies"
+    },
+    "is_active": {
+      "type": "boolean",
+      "default": true,
+      "required": true
+    },
+    "priority": {
+      "type": "integer",
+      "default": 0,
+      "required": false,
+      "description": "Higher priority rules are evaluated first"
+    },
+    "applies_to_methods": {
+      "type": "relation",
+      "relation": "manyToMany",
+      "target": "plugin::webbycommerce.shipping-method",
+      "required": false,
+      "description": "Shipping methods this rule applies to (empty/null for all)"
+    }
+  }
+}

package/server/src/content-types/shipping-zone/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const schema = require('./schema.json');
+
+module.exports = {
+  schema,
+};

package/server/src/content-types/shipping-zone/schema.json

@@ -0,0 +1,57 @@
+{
+  "kind": "collectionType",
+  "collectionName": "shipping_zones",
+  "info": {
+    "singularName": "shipping-zone",
+    "pluralName": "shipping-zones",
+    "displayName": "Shipping Zone",
+    "description": "Geographical shipping zones for rate calculation"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {
+    "content-manager": {
+      "visible": true
+    },
+    "content-api": {
+      "visible": true
+    }
+  },
+  "attributes": {
+    "name": {
+      "type": "string",
+      "required": true,
+      "unique": true
+    },
+    "description": {
+      "type": "text",
+      "required": false
+    },
+    "location": {
+      "type": "component",
+      "repeatable": true,
+      "component": "plugin::webbycommerce.shipping-zone-location",
+      "required": false,
+      "description": "Location rules for matching shipping addresses"
+    },
+    "is_active": {
+      "type": "boolean",
+      "default": true,
+      "required": true
+    },
+    "sort_order": {
+      "type": "integer",
+      "default": 0,
+      "required": false
+    },
+    "shippingMethods": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "plugin::webbycommerce.shipping-method",
+      "required": false
+
+      
+    }
+  }
+}

package/server/src/content-types/wishlist.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * wishlist.js
+ *
+ * Wishlist content type lifecycle
+ */
+
+const schema = {
+  kind: 'collectionType',
+  collectionName: 'wishlists',
+  info: {
+    singularName: 'wishlist',
+    pluralName: 'wishlists',
+    displayName: 'Wishlist',
+    description: 'User wishlist for storing favorite products',
+  },
+  options: {
+    draftAndPublish: false,
+    timestamps: true,
+  },
+  pluginOptions: {
+    'content-manager': {
+      visible: true,
+    },
+    'content-type-builder': {
+      visible: true,
+    },
+  },
+  attributes: {
+    userId: {
+      type: 'string',
+      required: true,
+      configurable: false,
+    },
+    userEmail: {
+      type: 'email',
+      required: true,
+      configurable: false,
+    },
+    products: {
+      type: 'relation',
+      relation: 'manyToMany',
+      target: 'plugin::webbycommerce.product',
+      mappedBy: 'wishlists',
+    },
+    isPublic: {
+      type: 'boolean',
+      default: false,
+      required: false,
+    },
+    name: {
+      type: 'string',
+      maxLength: 100,
+      required: false,
+    },
+    description: {
+      type: 'text',
+      required: false,
+    },
+  },
+};
+
+module.exports = {
+  schema,
+};

package/server/src/controllers/address.js

@@ -0,0 +1,374 @@
+'use strict';
+
+const PLUGIN_ID = 'webbycommerce';
+const { ensureEcommercePermission } = require('../utils/check-ecommerce-permission');
+
+const getStore = () => {
+  return strapi.store({ type: 'plugin', name: PLUGIN_ID });
+};
+
+const getShippingType = async () => {
+  const store = getStore();
+  const value = (await store.get({ key: 'settings' })) || {};
+  return value.shippingType || 'single'; // 'single' or 'multiple'
+};
+
+module.exports = {
+  /**
+   * Get all addresses for authenticated user
+   */
+  async getAddresses(ctx) {
+    try {
+      // Check ecommerce permission
+      const hasPermission = await ensureEcommercePermission(ctx);
+      if (!hasPermission) {
+        return;
+      }
+
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required. Please provide a valid JWT token.');
+      }
+
+      const { type } = ctx.query; // Optional filter: type=0 (billing) or type=1 (shipping)
+
+      const where = { user: user.id };
+      if (type !== undefined) {
+        where.type = parseInt(type, 10);
+      }
+
+      const addresses = await strapi.db.query('plugin::webbycommerce.address').findMany({
+        where,
+        orderBy: { createdAt: 'desc' },
+      });
+
+      ctx.send({ data: addresses });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in getAddresses:`, error);
+      ctx.internalServerError('Failed to fetch addresses. Please try again.');
+    }
+  },
+
+  /**
+   * Get single address by ID
+   */
+  async getAddress(ctx) {
+    try {
+      const hasPermission = await ensureEcommercePermission(ctx);
+      if (!hasPermission) {
+        return;
+      }
+
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required. Please provide a valid JWT token.');
+      }
+
+      const { id } = ctx.params;
+
+      const address = await strapi.db.query('plugin::webbycommerce.address').findOne({
+        where: { id, user: user.id },
+      });
+
+      if (!address) {
+        return ctx.notFound('Address not found.');
+      }
+
+      ctx.send({ data: address });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in getAddress:`, error);
+      ctx.internalServerError('Failed to fetch address. Please try again.');
+    }
+  },
+
+  /**
+   * Create new address
+   */
+  async createAddress(ctx) {
+    try {
+      const hasPermission = await ensureEcommercePermission(ctx);
+      if (!hasPermission) {
+        return;
+      }
+
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required. Please provide a valid JWT token.');
+      }
+
+      const shippingType = await getShippingType();
+      const {
+        type,
+        first_name,
+        last_name,
+        company_name,
+        country,
+        region,
+        city,
+        street_address,
+        postcode,
+        phone,
+        email_address,
+      } = ctx.request.body || {};
+
+      // Validate required fields - convert type to integer for validation
+      // Check if type exists in request body
+      if (type === undefined || type === null) {
+        return ctx.badRequest('Type is required and must be 0 (billing) or 1 (shipping).');
+      }
+      
+      // Convert to number - handle both string and number inputs
+      // Accept: 0, 1, "0", "1", 0.0, 1.0
+      let typeInt;
+      if (type === 0 || type === '0' || type === 0.0) {
+        typeInt = 0;
+      } else if (type === 1 || type === '1' || type === 1.0) {
+        typeInt = 1;
+      } else {
+        // Try parsing as number
+        typeInt = Number(type);
+        if (isNaN(typeInt) || (typeInt !== 0 && typeInt !== 1)) {
+          return ctx.badRequest('Type is required and must be 0 (billing) or 1 (shipping).');
+        }
+      }
+
+      if (!first_name || typeof first_name !== 'string' || first_name.trim().length === 0) {
+        return ctx.badRequest('First name is required.');
+      }
+
+      if (!last_name || typeof last_name !== 'string' || last_name.trim().length === 0) {
+        return ctx.badRequest('Last name is required.');
+      }
+
+      if (!country || typeof country !== 'string' || country.trim().length === 0) {
+        return ctx.badRequest('Country is required.');
+      }
+
+      if (!city || typeof city !== 'string' || city.trim().length === 0) {
+        return ctx.badRequest('City is required.');
+      }
+
+      if (!street_address || typeof street_address !== 'string' || street_address.trim().length === 0) {
+        return ctx.badRequest('Street address is required.');
+      }
+
+      if (!postcode || typeof postcode !== 'string' || postcode.trim().length === 0) {
+        return ctx.badRequest('Postcode is required.');
+      }
+
+      if (!phone || typeof phone !== 'string' || phone.trim().length === 0) {
+        return ctx.badRequest('Phone is required.');
+      }
+
+      // Email is required for billing addresses
+      if (typeInt === 0 && (!email_address || typeof email_address !== 'string' || email_address.trim().length === 0)) {
+        return ctx.badRequest('Email address is required for billing addresses.');
+      }
+
+      // Validate email format if provided
+      if (email_address) {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        if (!emailRegex.test(email_address.trim())) {
+          return ctx.badRequest('Invalid email format.');
+        }
+      }
+
+      // Check if single mode and address already exists
+      if (shippingType === 'single') {
+        const existingAddress = await strapi.db.query('plugin::webbycommerce.address').findOne({
+          where: { user: user.id, type: typeInt },
+        });
+
+        if (existingAddress) {
+          return ctx.forbidden(
+            `A ${typeInt === 0 ? 'billing' : 'shipping'} address already exists. Please update the existing address or enable multiple address mode in settings.`
+          );
+        }
+      }
+
+      // Create address
+      const address = await strapi.db.query('plugin::webbycommerce.address').create({
+        data: {
+          type: typeInt,
+          first_name: first_name.trim(),
+          last_name: last_name.trim(),
+          company_name: company_name ? company_name.trim() : null,
+          country: country.trim(),
+          region: region ? region.trim() : null,
+          city: city.trim(),
+          street_address: street_address.trim(),
+          postcode: postcode.trim(),
+          phone: phone.trim(),
+          email_address: email_address ? email_address.trim().toLowerCase() : null,
+          user: user.id,
+        },
+      });
+
+      ctx.send({ data: address });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in createAddress:`, error);
+      ctx.internalServerError('Failed to create address. Please try again.');
+    }
+  },
+
+  /**
+   * Update address
+   */
+  async updateAddress(ctx) {
+    try {
+      const hasPermission = await ensureEcommercePermission(ctx);
+      if (!hasPermission) {
+        return;
+      }
+
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required. Please provide a valid JWT token.');
+      }
+
+      const { id } = ctx.params;
+      const {
+        type,
+        first_name,
+        last_name,
+        company_name,
+        country,
+        region,
+        city,
+        street_address,
+        postcode,
+        phone,
+        email_address,
+      } = ctx.request.body;
+
+      // Verify address belongs to user
+      const existingAddress = await strapi.db.query('plugin::webbycommerce.address').findOne({
+        where: { id, user: user.id },
+      });
+
+      if (!existingAddress) {
+        return ctx.notFound('Address not found.');
+      }
+
+      // Validate type if provided
+      if (type !== undefined) {
+        const typeInt = parseInt(type, 10);
+        if (isNaN(typeInt) || (typeInt !== 0 && typeInt !== 1)) {
+          return ctx.badRequest('Type must be 0 (billing) or 1 (shipping).');
+        }
+      }
+
+      // Validate required fields if provided
+      if (first_name !== undefined && (!first_name || typeof first_name !== 'string' || first_name.trim().length === 0)) {
+        return ctx.badRequest('First name is required.');
+      }
+
+      if (last_name !== undefined && (!last_name || typeof last_name !== 'string' || last_name.trim().length === 0)) {
+        return ctx.badRequest('Last name is required.');
+      }
+
+      if (country !== undefined && (!country || typeof country !== 'string' || country.trim().length === 0)) {
+        return ctx.badRequest('Country is required.');
+      }
+
+      if (city !== undefined && (!city || typeof city !== 'string' || city.trim().length === 0)) {
+        return ctx.badRequest('City is required.');
+      }
+
+      if (street_address !== undefined && (!street_address || typeof street_address !== 'string' || street_address.trim().length === 0)) {
+        return ctx.badRequest('Street address is required.');
+      }
+
+      if (postcode !== undefined && (!postcode || typeof postcode !== 'string' || postcode.trim().length === 0)) {
+        return ctx.badRequest('Postcode is required.');
+      }
+
+      if (phone !== undefined && (!phone || typeof phone !== 'string' || phone.trim().length === 0)) {
+        return ctx.badRequest('Phone is required.');
+      }
+
+      // Validate email if provided
+      if (email_address !== undefined) {
+        const addressType = type !== undefined ? parseInt(type, 10) : existingAddress.type;
+        if (addressType === 0 && (!email_address || typeof email_address !== 'string' || email_address.trim().length === 0)) {
+          return ctx.badRequest('Email address is required for billing addresses.');
+        }
+
+        if (email_address) {
+          const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+          if (!emailRegex.test(email_address.trim())) {
+            return ctx.badRequest('Invalid email format.');
+          }
+        }
+      }
+
+      // Prepare update data
+      const updateData = {};
+      if (type !== undefined) {
+        const typeInt = parseInt(type, 10);
+        if (!isNaN(typeInt) && (typeInt === 0 || typeInt === 1)) {
+          updateData.type = typeInt;
+        }
+      }
+      if (first_name !== undefined) updateData.first_name = first_name.trim();
+      if (last_name !== undefined) updateData.last_name = last_name.trim();
+      if (company_name !== undefined) updateData.company_name = company_name ? company_name.trim() : null;
+      if (country !== undefined) updateData.country = country.trim();
+      if (region !== undefined) updateData.region = region ? region.trim() : null;
+      if (city !== undefined) updateData.city = city.trim();
+      if (street_address !== undefined) updateData.street_address = street_address.trim();
+      if (postcode !== undefined) updateData.postcode = postcode.trim();
+      if (phone !== undefined) updateData.phone = phone.trim();
+      if (email_address !== undefined) updateData.email_address = email_address ? email_address.trim().toLowerCase() : null;
+
+      // Update address
+      const updatedAddress = await strapi.db.query('plugin::webbycommerce.address').update({
+        where: { id },
+        data: updateData,
+      });
+
+      ctx.send({ data: updatedAddress });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in updateAddress:`, error);
+      ctx.internalServerError('Failed to update address. Please try again.');
+    }
+  },
+
+  /**
+   * Delete address
+   */
+  async deleteAddress(ctx) {
+    try {
+      const hasPermission = await ensureEcommercePermission(ctx);
+      if (!hasPermission) {
+        return;
+      }
+
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required. Please provide a valid JWT token.');
+      }
+
+      const { id } = ctx.params;
+
+      // Verify address belongs to user
+      const address = await strapi.db.query('plugin::webbycommerce.address').findOne({
+        where: { id, user: user.id },
+      });
+
+      if (!address) {
+        return ctx.notFound('Address not found.');
+      }
+
+      await strapi.db.query('plugin::webbycommerce.address').delete({
+        where: { id },
+      });
+
+      ctx.send({ data: { id } });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in deleteAddress:`, error);
+      ctx.internalServerError('Failed to delete address. Please try again.');
+    }
+  },
+};
+