@ozdao/martyrs 0.2.477 → 0.2.479

package/src/modules/inventory/store/ inventory.store.js

@@ -0,0 +1,131 @@
+import { reactive, watch } from 'vue';
+import { setError } from '@martyrs/src/modules/globals/views/store/globals.js';
+import $axios from '@martyrs/src/modules/globals/views/utils/axios-instance.js';
+
+const state = reactive({
+  adjustments: [],
+  balance: [],
+  availability: [],
+  inventories: [],
+  current: {
+    storage: null,
+    positions: [],
+    comment: ''
+  },
+  filters: {
+    storage: null,
+    product: null,
+    dateStart: null,
+    dateEnd: null
+  }
+});
+
+const actions = {
+  // Adjustments
+  async fetchAdjustments(options = {}) {
+    try {
+      const params = { ...state.filters, ...options };
+      const response = await $axios.get('/api/inventory/adjustments', { params });
+      state.adjustments = response.data;
+      return response.data;
+    } catch (error) {
+      setError(error);
+      throw error;
+    }
+  },
+  
+  async createAdjustment(data) {
+    try {
+      const response = await $axios.post('/api/inventory/adjustments/create', data);
+      state.adjustments.unshift(response.data);
+      return response.data;
+    } catch (error) {
+      setError(error);
+      throw error;
+    }
+  },
+  
+  // Balance
+  async fetchBalance(options = {}) {
+    try {
+      const params = { ...state.filters, ...options };
+      const response = await $axios.get('/api/inventory/balance', { params });
+      state.balance = response.data;
+      return response.data;
+    } catch (error) {
+      setError(error);
+      throw error;
+    }
+  },
+  
+  // Availability
+  async fetchAvailability(options = {}) {
+    try {
+      const response = await $axios.get('/api/inventory/availability', { params: options });
+      state.availability = response.data;
+      return response.data;
+    } catch (error) {
+      setError(error);
+      throw error;
+    }
+  },
+  
+  // Inventory audits
+  async fetchInventories(options = {}) {
+    try {
+      const response = await $axios.get('/api/inventory/audits', { params: options });
+      state.inventories = response.data;
+      return response.data;
+    } catch (error) {
+      setError(error);
+      throw error;
+    }
+  },
+  
+  async createInventory(data) {
+    try {
+      const response = await $axios.post('/api/inventory/audits/create', data);
+      state.inventories.unshift(response.data);
+      return response.data;
+    } catch (error) {
+      setError(error);
+      throw error;
+    }
+  },
+  
+  async completeInventory(id) {
+    try {
+      const response = await $axios.post('/api/inventory/audits/complete', { _id: id });
+      const index = state.inventories.findIndex(i => i._id === id);
+      if (index > -1) state.inventories[index] = response.data;
+      return response.data;
+    } catch (error) {
+      setError(error);
+      throw error;
+    }
+  }
+};
+
+const mutations = {
+  resetCurrent() {
+    state.current = {
+      storage: null,
+      positions: [],
+      comment: ''
+    };
+  },
+  
+  setFilters(filters) {
+    state.filters = { ...state.filters, ...filters };
+  },
+  
+  addPosition(position) {
+    state.current.positions.push(position);
+  },
+  
+  removePosition(index) {
+    state.current.positions.splice(index, 1);
+  }
+};
+
+export { state, actions, mutations };

package/src/modules/inventory/workers/inventory.availability.worker.js

@@ -0,0 +1,300 @@
+/**
+ * Worker for recalculating product availability based on stock balances
+ * and ingredient requirements
+ */
+class AvailabilityWorker {
+  constructor(db) {
+    this.db = db;
+    this.logger = console;
+    
+    // Initialize change stream if not in test environment
+    if (process.env.NODE_ENV !== 'test') {
+      this.initChangeStream();
+    }
+  }
+  
+  /**
+   * Initialize change stream to watch for stock balance changes
+   */
+  initChangeStream() {
+    try {
+      const stockBalance = this.db.stockBalance;
+      
+      stockBalance.collection.watch(
+        [{ $match: { operationType: { $in: ['insert', 'update', 'replace'] } } }],
+        { fullDocument: 'updateLookup' } // Critical to get the complete document after updates
+      ).on('change', async (event) => {
+        try {
+          // Only proceed if we have the full document
+          if (!event.fullDocument) {
+            this.logger.warn('Missing fullDocument in change event, skipping recalculation');
+            return;
+          }
+          
+          const { product, storage } = event.fullDocument;
+          
+          // Process asynchronously to not block the event loop
+          process.nextTick(() => {
+            this.recalcByProduct(product, storage)
+              .catch(err => this.logger.error('Error in change stream recalculation:', err));
+          });
+        } catch (error) {
+          this.logger.error('Error in stock balance change stream:', error);
+        }
+      });
+      
+      this.logger.info('Stock balance change stream initialized');
+    } catch (error) {
+      this.logger.error('Error initializing change stream:', error);
+      // If change streams aren't supported, fall back to timer-based updates
+      this.initPeriodicUpdates();
+    }
+  }
+  
+  /**
+   * Fallback method for databases without change stream support
+   */
+  initPeriodicUpdates() {
+    const REFRESH_INTERVAL = 60000; // 1 minute
+    
+    setInterval(async () => {
+      try {
+        const stockBalance = this.db.stockBalance;
+        
+        // Find recently updated balances (in the last interval)
+        // Use index on updatedAt for efficient querying
+        const recentUpdates = await stockBalance.find({
+          updatedAt: { $gte: new Date(Date.now() - REFRESH_INTERVAL * 2) }
+        })
+        .sort({ updatedAt: -1 })
+        .lean();
+        
+        // Group by product+storage to avoid duplicate recalcs
+        const updates = new Map();
+        recentUpdates.forEach(balance => {
+          const key = `${balance.product.toString()}_${balance.storage.toString()}`;
+          updates.set(key, { product: balance.product, storage: balance.storage });
+        });
+        
+        // Process each unique product+storage asynchronously
+        for (const { product, storage } of updates.values()) {
+          process.nextTick(() => {
+            this.recalcByProduct(product, storage)
+              .catch(err => this.logger.error('Error in periodic recalculation:', err));
+          });
+        }
+      } catch (error) {
+        this.logger.error('Error in periodic availability update:', error);
+      }
+    }, REFRESH_INTERVAL);
+    
+    this.logger.info('Periodic availability updates initialized');
+  }
+  
+  /**
+   * Recalculate availability for a specific product at a specific storage location
+   * 
+   * @param {ObjectId} product - Product ID
+   * @param {ObjectId} storage - Storage ID
+   * @param {ClientSession} [session] - MongoDB session (optional)
+   */
+  async recalcByProduct(product, storage, session = null) {
+    try {
+      const Product = this.db.product;
+      const StockBalance = this.db.stockBalance;
+      const StockAvailability = this.db.stockAvailability;
+      
+      // Get the product with its variants - using $lookup instead of populate for better performance
+      const productData = await Product.aggregate([
+        { $match: { _id: this.db.mongoose.Types.ObjectId(product) } },
+        {
+          $lookup: {
+            from: 'variants',
+            localField: 'variants',
+            foreignField: '_id',
+            as: 'variantsData'
+          }
+        },
+        {
+          $project: {
+            _id: 1,
+            name: 1,
+            sku: 1,
+            ingredients: 1,
+            variantsData: {
+              _id: 1,
+              ingredients: 1
+            }
+          }
+        }
+      ]).session(session).then(results => results[0]);
+      
+      if (!productData) {
+        this.logger.warn(`Product ${product} not found for availability recalculation`);
+        return;
+      }
+      
+      // Get all variant IDs for this product
+      const variantIds = productData.variantsData?.map(v => v._id) || [];
+      
+      // Add explicit base product (no variant) - better than null for indexing
+      const explicitBaseVariantId = '000000000000000000000000'; // ObjectId for base variant
+      
+      // Get all balances for this product's variants at this storage
+      const balances = await StockBalance.find({
+        product,
+        $or: [
+          { variant: { $in: variantIds } },
+          { variant: { $exists: false } } // Base product has no variant field
+        ],
+        storage
+      }).session(session).lean();
+      
+      // Create a map for quick lookup
+      const balanceMap = new Map();
+      balances.forEach(balance => {
+        const key = balance.variant ? balance.variant.toString() : explicitBaseVariantId;
+        balanceMap.set(key, balance);
+      });
+      
+      // Get all ingredient IDs from product and variants
+      const ingredientIds = new Set();
+      
+      // Add product's ingredients
+      if (productData.ingredients && productData.ingredients.length > 0) {
+        productData.ingredients.forEach(ing => ingredientIds.add(ing._id.toString()));
+      }
+      
+      // Add variant's ingredients
+      if (productData.variantsData) {
+        productData.variantsData.forEach(variant => {
+          if (variant.ingredients && variant.ingredients.length > 0) {
+            variant.ingredients.forEach(ing => ingredientIds.add(ing._id.toString()));
+          }
+        });
+      }
+      
+      // Get ingredient balances if needed
+      let ingredientBalances = [];
+      if (ingredientIds.size > 0) {
+        ingredientBalances = await StockBalance.find({
+          product: { $in: Array.from(ingredientIds).map(id => this.db.mongoose.Types.ObjectId(id)) },
+          storage
+        }).session(session).lean();
+      }
+      
+      // Create ingredient balance map
+      const ingredientMap = new Map();
+      ingredientBalances.forEach(balance => {
+        ingredientMap.set(balance.product.toString(), balance);
+      });
+      
+      // Prepare bulk operations for StockAvailability updates
+      const bulkOps = [];
+      
+      // Process base product first
+      this._processVariantAvailability(
+        bulkOps, 
+        product, 
+        null, // null variant for base product
+        storage,
+        productData, 
+        balanceMap.get(explicitBaseVariantId), 
+        ingredientMap
+      );
+      
+      // Process each variant
+      for (const variant of productData.variantsData || []) {
+        this._processVariantAvailability(
+          bulkOps, 
+          product, 
+          variant._id, 
+          storage,
+          variant, 
+          balanceMap.get(variant._id.toString()), 
+          ingredientMap
+        );
+      }
+      
+      // Execute bulk operations
+      if (bulkOps.length > 0) {
+        const result = await StockAvailability.bulkWrite(bulkOps, { session });
+        return result;
+      }
+      
+      return null;
+    } catch (error) {
+      this.logger.error(`Error recalculating availability for product ${product}:`, error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Helper to process a single variant's availability
+   */
+  _processVariantAvailability(bulkOps, productId, variantId, storageId, variant, balance, ingredientMap) {
+    // Default values if no balance found
+    const stockQuantity = balance ? balance.quantity : 0;
+    
+    // Start with direct stock
+    let availableQuantity = stockQuantity;
+    
+    // Track ingredient constraints
+    const constraints = [];
+    
+    // Process ingredients if they exist
+    if (variant.ingredients && variant.ingredients.length > 0) {
+      for (const ingredient of variant.ingredients) {
+        const ingId = ingredient._id.toString();
+        const requiredQty = ingredient.quantity || 0;
+        
+        // Skip optional ingredients
+        if (ingredient.optional) continue;
+        
+        const ingBalance = ingredientMap.get(ingId);
+        const stockIng = ingBalance ? ingBalance.quantity : 0;
+        
+        // Calculate how many products can be made with this ingredient
+        if (requiredQty > 0) {
+          const possibleQty = Math.floor(stockIng / requiredQty);
+          
+          // Track ingredient constraint
+          constraints.push({
+            ingredient: ingredient._id,
+            stock: stockIng,
+            required: requiredQty,
+            available: possibleQty
+          });
+          
+          // Take the minimum between current available and what ingredients allow
+          availableQuantity = Math.min(availableQuantity, possibleQty);
+        }
+      }
+    }
+    
+    // Ensure available doesn't go negative
+    availableQuantity = Math.max(0, availableQuantity);
+    
+    // Create update operation
+    bulkOps.push({
+      updateOne: {
+        filter: {
+          product: productId,
+          variant: variantId,
+          storage: storageId
+        },
+        update: {
+          $set: {
+            quantity: stockQuantity,
+            available: availableQuantity,
+            constraints,
+            updatedAt: new Date()
+          }
+        },
+        upsert: true
+      }
+    });
+  }
+}
+
+export default AvailabilityWorker;

package/src/modules/landing/landing.client.js

@@ -1,30 +1,30 @@
 // Importing Vue components
+import SectionEarn from './components/sections/SectionEarn.vue';
 import SectionFeatures from './components/sections/SectionFeatures.vue';
-import SectionMobileApp from './components/sections/SectionMobileApp.vue';
+import SectionGuide from './components/sections/SectionGuide.vue';
 import SectionJoinUs from './components/sections/SectionJoinUs.vue';
+import SectionMobileApp from './components/sections/SectionMobileApp.vue';
+import SectionOverview from './components/sections/SectionOverview.vue';
 import SubscribeNewsletter from './components/sections/SubscribeNewsletter.vue';
-import SectionEarn from './components/sections/SectionEarn.vue';
-import SectionGuide from './components/sections/SectionGuide.vue';
-import SectionOverview  from './components/sections/SectionOverview.vue';
 
-import FloatingImages from './components/elements/FloatingImages.vue';
 import AnimatedGrid from './components/elements/AnimatedGrid.vue';
+import FloatingImages from './components/elements/FloatingImages.vue';
 
-import SectionHeroToken  from './components/sections/SectionHeroToken.vue';
-import SectionFeaturesImages  from './components/sections/SectionFeaturesImages.vue';
-import SectionRoadmap  from './components/sections/SectionRoadmap.vue';
+import SectionFeaturesImages from './components/sections/SectionFeaturesImages.vue';
+import SectionHeroToken from './components/sections/SectionHeroToken.vue';
+import SectionRoadmap from './components/sections/SectionRoadmap.vue';
 
 export {
+  AnimatedGrid,
+  FloatingImages,
   SectionEarn,
-  SectionMobileApp,
-  SectionGuide,
-  SectionOverview,
-  SectionJoinUs,
-  SubscribeNewsletter,
   SectionFeatures,
-  FloatingImages,
-  SectionHeroToken,
   SectionFeaturesImages,
+  SectionGuide,
+  SectionHeroToken,
+  SectionJoinUs,
+  SectionMobileApp,
+  SectionOverview,
   SectionRoadmap,
-  AnimatedGrid
+  SubscribeNewsletter,
 };

package/src/modules/marketplace/marketplace.client.js

@@ -4,7 +4,7 @@ import routerMarketplace from './views/router/marketplace.router.js';
 //Store
 import * as storeMarketplace from './views/store/marketplace.js';
 
-// Layouts 
+// Layouts
 import Marketplace from './views/components/layouts/Marketplace.vue';
 
 // Sections
@@ -18,7 +18,7 @@ function initializeProducts(app, store, router, options = {}) {
   const route = options.route || 'Home';
 
   router.addRoute(route, routerMarketplace);
-  
+
   store.addStore('marketplace', storeMarketplace);
 }
 
@@ -29,8 +29,7 @@ const ModuleMarketplace = {
       storeMarketplace,
     },
     router: {
-      
-      routerMarketplace
+      routerMarketplace,
     },
     components: {
       // Elements
@@ -40,20 +39,20 @@ const ModuleMarketplace = {
       // Pages
       Catalog,
       // Layouts
-      Marketplace
-    }
-  }
-}
+      Marketplace,
+    },
+  },
+};
 
 export {
-  // Blocks
-  // Sections
-  SectionMenu,
   // Elements
   // Pages
   Catalog,
   // Layouts
-  Marketplace
+  Marketplace,
+  // Blocks
+  // Sections
+  SectionMenu,
 };
 
-export default ModuleMarketplace;
+export default ModuleMarketplace;

package/src/modules/marketplace/views/components/layouts/Marketplace.vue

@@ -51,8 +51,8 @@
 
 	import BlockFilter  from '@martyrs/src/modules/globals/views/components/blocks/BlockFilter.vue'
 
-	import * as globals from '@martyrs/src/modules/globals/views/store/globals'
-  import * as categories from '@martyrs/src/modules/products/store/categories';
+	import * as globals from '@martyrs/src/modules/globals/views/store/globals.js'
+  import * as categories from '@martyrs/src/modules/products/store/categories.js';
 
 
 	import * as marketplace from '../../store/marketplace';

package/src/modules/marketplace/views/components/pages/Catalog.vue

@@ -47,8 +47,8 @@
 
 	import Feed from '@martyrs/src/components/Feed/Feed.vue'
 	
-	import * as organization from '@martyrs/src/modules/organizations/store/organizations'
-	import * as globals from '@martyrs/src/modules/globals/views/store/globals'
+	import * as organization from '@martyrs/src/modules/organizations/store/organizations.js'
+	import * as globals from '@martyrs/src/modules/globals/views/store/globals.js'
 
 	import CardOrganization from '@martyrs/src/modules/organizations/components/blocks/CardOrganization.vue'
 

package/src/modules/marketplace/views/components/sections/SectionMenu.vue

@@ -53,8 +53,8 @@
 	import { useRouter } from 'vue-router'
 	import { useI18n } from 'vue-i18n'
 		
-	import * as categories from '@martyrs/src/modules/products/store/categories';
-	import * as products from '@martyrs/src/modules/products/store/products';
+	import * as categories from '@martyrs/src/modules/products/store/categories.js';
+	import * as products from '@martyrs/src/modules/products/store/products.js';
 
 	const router = useRouter()
 

package/src/modules/marketplace/views/router/marketplace.router.js

@@ -1,6 +1,4 @@
-import layoutEmpty from '@martyrs/src/modules/globals/views/components/layouts/Empty.vue'
-
-import layoutMarketplace from '../components/layouts/Marketplace.vue'
+import layoutMarketplace from '../components/layouts/Marketplace.vue';
 
 const marketplace = {
   path: 'marketplace',
@@ -9,8 +7,8 @@ const marketplace = {
   meta: {
     title: {
       en: 'Marketplace',
-      ru: 'Маркетплейс'
-    }
+      ru: 'Маркетплейс',
+    },
   },
   children: [
     {
@@ -26,12 +24,12 @@ const marketplace = {
               path: ':city?',
               name: 'City',
               component: () => import(/* webpackChunkName: 'Deliveries' */ '../components/pages/Catalog.vue'),
-            }
-          ]
-        }
-      ]
+            },
+          ],
+        },
+      ],
     },
   ],
-}
+};
 
-export default marketplace;
+export default marketplace;

package/src/modules/marketplace/views/store/marketplace.js

@@ -1,4 +1,4 @@
-import { reactive, watch  } from "vue";
+import { reactive, watch } from 'vue';
 
 // State
 const state = reactive({
@@ -11,48 +11,52 @@ const state = reactive({
   search: {
     active: false,
     current: '',
-    result:[]
+    result: [],
   },
   filter: {
     active: false,
     class: 'mobile-only',
     selected: {},
-    options: [{
-      title: 'Delivery',
-      value: 'delivery',
-      options: [
-        { label: 'Pickup', value: 'pickup' },
-        { label: 'Courier', value: 'courier' },
-        { label: 'Post', value: 'post' }
-      ]
-    }],
+    options: [
+      {
+        title: 'Delivery',
+        value: 'delivery',
+        options: [
+          { label: 'Pickup', value: 'pickup' },
+          { label: 'Courier', value: 'courier' },
+          { label: 'Post', value: 'post' },
+        ],
+      },
+    ],
   },
   sort: {
     param: 'distance',
     order: 'asc',
-    options: [{
-      label: 'Distance',
-      value: 'distance'
-    },{
-      label: 'Popularity',
-      value: 'views'
-    },{
-      label: 'Products',
-      value: 'numberOfProducts'
-    }]
-  }
+    options: [
+      {
+        label: 'Distance',
+        value: 'distance',
+      },
+      {
+        label: 'Popularity',
+        value: 'views',
+      },
+      {
+        label: 'Products',
+        value: 'numberOfProducts',
+      },
+    ],
+  },
 });
 
-
 // History
-const history = []; history.push(state);
+const history = [];
+history.push(state);
 
 // Watch
 watch(state, (newState, oldState) => {
-  history.push(newState)
-})
+  history.push(newState);
+});
 
 // Module Export
-export {
-  state
-}
+export { state };