@ozdao/martyrs 0.2.561 → 0.2.563

package/src/modules/core/views/components/sections/filters/FiltersGroup.vue

@@ -0,0 +1,177 @@
+<template>
+  <div>
+    <div v-if="showHeader" class="flex-v-center flex-nowrap flex mn-b-medium">
+      <h3 class="flex-child-full">Filters</h3>
+    </div>
+
+    <div class="filters-content">
+      <div
+        v-for="filter in filters"
+        :key="filter.value"
+        class="mn-b-medium"
+      >
+        <h4 class="mn-b-small">{{ filter.title }}</h4>
+
+        <!-- Checkbox Filter -->
+        <FilterCheckbox
+          v-if="filter.type === 'checkbox'"
+          v-model="workingValues[filter.value]"
+          :options="filter.options"
+          @apply="handleApply(filter.value)"
+        />
+
+        <!-- Range Filter -->
+        <FilterRange
+          v-else-if="filter.type === 'range'"
+          v-model="workingValues[filter.value]"
+          :minPlaceholder="filter.minPlaceholder || 'Min'"
+          :maxPlaceholder="filter.maxPlaceholder || 'Max'"
+          :label="filter.label"
+          @apply="handleApply(filter.value)"
+        />
+
+        <!-- Date Filter -->
+        <FilterDateRange
+          v-else-if="filter.type === 'date'"
+          v-model="workingValues[filter.value]"
+          @apply="handleApply(filter.value)"
+        />
+
+        <!-- Radio/Options Filter -->
+        <FilterOptions
+          v-else-if="filter.type === 'radio'"
+          v-model="workingValues[filter.value]"
+          :options="filter.options"
+        />
+      </div>
+    </div>
+
+    <div class="flex gap-thin mn-t-medium">
+      <button
+        v-if="showApplyButton"
+        @click="applyFilters"
+        class="button bg-main flex-child-full"
+      >
+        Apply
+      </button>
+      <button
+        v-if="showResetButton"
+        @click="resetFilters"
+        class="button bg-light"
+        :class="{ 'flex-child-full': !showApplyButton }"
+      >
+        Reset Filters
+      </button>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { ref, reactive, watch } from 'vue'
+import { useGlobalMixins } from '@martyrs/src/modules/core/views/mixins/mixins.js'
+import FilterCheckbox from './FilterCheckbox.vue'
+import FilterRange from './FilterRange.vue'
+import FilterDateRange from './FilterDateRange.vue'
+import FilterOptions from './FilterOptions.vue'
+
+const props = defineProps({
+  filters: {
+    type: Array,
+    required: true
+  },
+  immediate: {
+    type: Boolean,
+    default: false
+  },
+  showHeader: {
+    type: Boolean,
+    default: true
+  },
+  showApplyButton: {
+    type: Boolean,
+    default: false
+  },
+  showResetButton: {
+    type: Boolean,
+    default: true
+  }
+})
+
+const selected = defineModel('selected', {
+  type: Object,
+  default: () => ({})
+})
+
+const { returnCurrency } = useGlobalMixins()
+
+const workingValues = reactive({})
+
+// Initialize working values
+watch(() => props.filters, (newFilters) => {
+  newFilters.forEach(filter => {
+    if (!workingValues[filter.value]) {
+      if (filter.type === 'checkbox') {
+        workingValues[filter.value] = [...(selected.value[filter.value] || [])]
+      } else if (filter.type === 'range') {
+        workingValues[filter.value] = { ...(selected.value[filter.value] || { min: '', max: '' }) }
+      } else if (filter.type === 'date') {
+        workingValues[filter.value] = selected.value[filter.value] || null
+      } else {
+        workingValues[filter.value] = selected.value[filter.value] || null
+      }
+    }
+  })
+}, { immediate: true, deep: true })
+
+// Sync selected to workingValues
+watch(selected, (newValue) => {
+  Object.keys(newValue).forEach(key => {
+    const filter = props.filters.find(f => f.value === key)
+    if (filter) {
+      if (filter.type === 'checkbox') {
+        workingValues[key] = [...(newValue[key] || [])]
+      } else if (filter.type === 'range') {
+        workingValues[key] = { ...(newValue[key] || { min: '', max: '' }) }
+      } else {
+        workingValues[key] = newValue[key]
+      }
+    }
+  })
+}, { deep: true })
+
+const handleApply = (filterValue) => {
+  if (props.immediate) {
+    const updated = { ...selected.value }
+    updated[filterValue] = workingValues[filterValue]
+    selected.value = updated
+  }
+}
+
+const applyFilters = () => {
+  const updated = {}
+  Object.keys(workingValues).forEach(key => {
+    updated[key] = workingValues[key]
+  })
+  selected.value = updated
+}
+
+const resetFilters = () => {
+  props.filters.forEach(filter => {
+    if (filter.type === 'checkbox') {
+      workingValues[filter.value] = []
+    } else if (filter.type === 'range') {
+      workingValues[filter.value] = { min: '', max: '' }
+    } else if (filter.type === 'date') {
+      workingValues[filter.value] = null
+    } else {
+      workingValues[filter.value] = null
+    }
+
+    // Удаляем ключ из selected
+    delete selected.value[filter.value]
+  })
+}
+</script>
+
+<style scoped>
+</style>

package/src/modules/core/views/utils/vue-app-renderer.js

@@ -79,6 +79,8 @@ export function renderAndMountApp({ createApp, hooks = {} }) {
     }
 
 
+
+
     if (initialState) {
       console.log('[AUTH COOKIE DEBUG] Browser initialState.auth:', initialState.auth);
       console.log('[AUTH COOKIE DEBUG] Has token?', !!initialState?.auth?.access?.token);
@@ -89,6 +91,7 @@ export function renderAndMountApp({ createApp, hooks = {} }) {
 
       if (initialState?.auth?.access?.token) {
         console.log('[AUTH COOKIE DEBUG] Setting auth token from initialState');
+
         setAuthToken(initialState.auth.access.token);
       } else if (initialState?.auth && !initialState.auth.access?.status) {
         // Если SSR сбросил auth (из-за ошибки), удаляем куку в браузере
@@ -106,6 +109,12 @@ export function renderAndMountApp({ createApp, hooks = {} }) {
       }
     }
 
+    const savedPosition = localStorage.getItem('position');
+
+    if (savedPosition) {
+      store.core.state.position = JSON.parse(savedPosition);
+    }
+
     // app.config.globalProperties.$i18n.locale = router.currentRoute.value.params.locale
     // app.config.globalProperties.$i18n.locale = router.currentRoute.value.params.locale
     // If user browser locae supported then change locale
@@ -171,6 +180,9 @@ export async function render({ url, cookies,  ssrContext, createApp}) {
     }
   }
 
+  
+
+
   if (user) {
     // [LOADING 27] SSR auth initialization
     performance.mark('loading-27-start');

package/src/modules/landing/components/sections/SectionFeatures.vue

@@ -1,6 +1,6 @@
 <template>
   <section id="howtobuy">
-    <h2 class="w-100 w-max-50r mn-b-small" v-html="t('title')"/>
+    <h2 class="w-100 w-max-50r mn-l-auto mn-r-auto mn-b-small" v-html="t('title')"/>
    
     <div class="cols-3 mobile:cols-1 gap-thin">
       <div 

package/src/modules/marketplace/controllers/marketplace.controller.js

@@ -0,0 +1,123 @@
+import Cache from '@martyrs/src/modules/core/controllers/classes/core.cache.js';
+import queryProcessorCore from '@martyrs/src/modules/core/controllers/utils/queryProcessor.js';
+import { getLookupStages } from '@martyrs/src/modules/organizations/controllers/utils/queryProcessorOrganizations.js';
+import lookupConfigs from './utils/lookupConfigs.js';
+import {
+  getBasicMatchConditions,
+  getPriceConditions,
+  getCategoryConditions,
+  getContainConditions,
+  getSpotsLocationStages,
+} from './utils/queryProcessorMarketplace.js';
+
+const controllerFactory = db => {
+  const Spot = db.spot;
+
+  const cache = new Cache({ ttlSeconds: 60 * 5 });
+
+  const readCatalog = async (req, res) => {
+    console.log('marketplace catalog query', req.query);
+
+    try {
+      const cacheKey = JSON.stringify(req.query);
+
+      let cachedResult = await cache.get(cacheKey);
+      if (cachedResult) {
+        return res.status(200).send(cachedResult);
+      }
+
+      const matchConditions = getBasicMatchConditions(req.query);
+
+      const stages = [
+        // Базовые фильтры spots (delivery, payment)
+        ...(matchConditions.length > 0 ? [{ $match: { $and: matchConditions } }] : []),
+
+        // Геопоиск ПЕРВЫМ (если есть location)
+        ...(req.query.location || req.query.city || req.query.state || req.query.country
+          ? (await getSpotsLocationStages(req.query)).stages
+          : [{ $addFields: { distance: null } }]),
+
+        // Lookups (без availability пока)
+        ...getLookupStages(['products', 'organizations'], lookupConfigs),
+
+        // Фильтр по наличию products
+        ...getContainConditions(['products', 'organizations']),
+
+        // Фильтр по ценам
+        ...getPriceConditions(req.query.priceMin, req.query.priceMax),
+
+        // Фильтр по категориям
+        ...getCategoryConditions(req.query.categories),
+
+        // Group по organization
+        {
+          $group: {
+            _id: { $arrayElemAt: ['$organizations._id', 0] },
+            profile: { $first: { $arrayElemAt: ['$organizations.profile', 0] } },
+            rating: { $first: { $arrayElemAt: ['$organizations.rating', 0] } },
+            official: { $first: { $arrayElemAt: ['$organizations.official', 0] } },
+            views: { $first: { $arrayElemAt: ['$organizations.views', 0] } },
+            spots: {
+              $push: {
+                _id: '$_id',
+                name: '$profile.name',
+                address: '$address',
+                location: '$location',
+                distance: '$distance',
+                delivery: '$delivery',
+                payment: '$payment',
+              },
+            },
+            products: { $first: '$products' },
+            distance: { $min: '$distance' },
+          },
+        },
+
+        // Добавляем numberOfProducts
+        {
+          $addFields: {
+            numberOfProducts: { $size: { $ifNull: ['$products', []] } },
+          },
+        },
+
+        // Финальная структура
+        {
+          $project: {
+            _id: 1,
+            profile: 1,
+            rating: 1,
+            official: 1,
+            views: 1,
+            spots: 1,
+            products: 1,
+            distance: 1,
+            numberOfProducts: 1,
+          },
+        },
+
+        // Сортировка
+        ...queryProcessorCore.getSortingOptions(req.query.sortParam || 'distance', req.query.sortOrder),
+
+        // Пагинация
+        ...queryProcessorCore.getPaginationOptions(req.query.skip, req.query.limit),
+      ].filter(Boolean);
+
+      console.log('Marketplace pipeline:', JSON.stringify(stages, null, 2));
+
+      const catalog = await Spot.aggregate(stages);
+
+      await cache.setWithTags(cacheKey, catalog, ['marketplace_catalog']);
+
+      res.status(200).send(catalog);
+    } catch (err) {
+      console.error('Marketplace catalog error:', err);
+      res.status(500).send({ message: err.message });
+    }
+  };
+
+  return {
+    readCatalog,
+  };
+};
+
+export default controllerFactory;

package/src/modules/marketplace/controllers/utils/lookupConfigs.js

@@ -0,0 +1,130 @@
+const lookupConfigs = {
+  availability: {
+    lookup: {
+      from: 'stockavailabilities',
+      localField: '_id',
+      foreignField: 'storage',
+      pipeline: [
+        {
+          $match: {
+            $expr: { $gt: ['$available', 0] },
+          },
+        },
+        {
+          $project: {
+            _id: 1,
+            product: 1,
+            variant: 1,
+            available: 1,
+            quantity: 1,
+          },
+        },
+      ],
+      as: 'availability',
+    },
+  },
+  variants: {
+    lookup: {
+      from: 'variants',
+      let: { variantIds: '$availability.variant' },
+      pipeline: [
+        {
+          $match: {
+            $expr: {
+              $in: ['$_id', '$$variantIds'],
+            },
+            status: 'published',
+          },
+        },
+        {
+          $project: {
+            _id: 1,
+            product: 1,
+            name: 1,
+            price: 1,
+            unit: 1,
+            images: 1,
+            sku: 1,
+          },
+        },
+      ],
+      as: 'variants',
+    },
+  },
+  products: {
+    lookup: {
+      from: 'products',
+      localField: 'organization',
+      foreignField: 'owner.target',
+      pipeline: [
+        {
+          $match: {
+            status: 'published',
+          },
+        },
+        {
+          $lookup: {
+            from: 'variants',
+            localField: '_id',
+            foreignField: 'product',
+            pipeline: [
+              {
+                $project: {
+                  _id: 1,
+                  name: 1,
+                  price: 1,
+                  unit: 1,
+                  images: 1,
+                  sku: 1,
+                },
+              },
+            ],
+            as: 'variants',
+          },
+        },
+        {
+          $project: {
+            _id: 1,
+            name: 1,
+            description: 1,
+            images: 1,
+            category: 1,
+            'owner.target': 1,
+            'owner.type': 1,
+            variants: 1,
+          },
+        },
+      ],
+      as: 'products',
+    },
+  },
+  organizations: {
+    lookup: {
+      from: 'organizations',
+      let: { orgIds: '$products.owner.target' },
+      pipeline: [
+        {
+          $match: {
+            $expr: {
+              $in: ['$_id', '$$orgIds'],
+            },
+          },
+        },
+        {
+          $project: {
+            _id: 1,
+            'profile.name': 1,
+            'profile.photo': 1,
+            'profile.description': 1,
+            'profile.tags': 1,
+            rating: 1,
+            official: 1,
+          },
+        },
+      ],
+      as: 'organizations',
+    },
+  },
+};
+
+export default lookupConfigs;

package/src/modules/marketplace/controllers/utils/queryProcessorMarketplace.js

@@ -0,0 +1,211 @@
+import { Types } from 'mongoose';
+import * as googleMapsServicesJs from '@googlemaps/google-maps-services-js';
+
+const ObjectId = Types.ObjectId;
+const { Client } = googleMapsServicesJs;
+const client = new Client({});
+
+/**
+ * Get basic match conditions for spots (delivery, payment)
+ */
+const getBasicMatchConditions = query => {
+  const conditions = [];
+
+  if (query.delivery) {
+    // Нормализуем в массив и фильтруем пустые значения
+    let deliveryMethods = Array.isArray(query.delivery)
+      ? query.delivery
+      : typeof query.delivery === 'string'
+      ? query.delivery.split(',')
+      : [];
+
+    deliveryMethods = deliveryMethods.filter(Boolean).map(m => m.trim());
+
+    if (deliveryMethods.length > 0) {
+      // $in = spots которые поддерживают ХОТЯ БЫ ОДИН метод
+      conditions.push({ delivery: { $in: deliveryMethods } });
+    }
+  }
+
+  if (query.payment) {
+    // Нормализуем в массив и фильтруем пустые значения
+    let paymentMethods = Array.isArray(query.payment)
+      ? query.payment
+      : typeof query.payment === 'string'
+      ? query.payment.split(',')
+      : [];
+
+    paymentMethods = paymentMethods.filter(Boolean).map(m => m.trim());
+
+    if (paymentMethods.length > 0) {
+      // $in = spots которые поддерживают ХОТЯ БЫ ОДИН метод
+      conditions.push({ payment: { $in: paymentMethods } });
+    }
+  }
+
+  return conditions;
+};
+
+/**
+ * Get price filter conditions for variants
+ */
+const getPriceConditions = (priceMin, priceMax) => {
+  if (!priceMin && !priceMax) return [];
+
+  const conditions = {};
+
+  if (priceMin !== undefined && priceMin !== null && priceMin !== '') {
+    conditions['products.variants.price'] = { $gte: parseFloat(priceMin) };
+  }
+
+  if (priceMax !== undefined && priceMax !== null && priceMax !== '') {
+    if (conditions['products.variants.price']) {
+      conditions['products.variants.price'].$lte = parseFloat(priceMax);
+    } else {
+      conditions['products.variants.price'] = { $lte: parseFloat(priceMax) };
+    }
+  }
+
+  return Object.keys(conditions).length > 0 ? [{ $match: conditions }] : [];
+};
+
+/**
+ * Get category filter conditions for products
+ */
+const getCategoryConditions = categories => {
+  if (!categories || categories.length === 0) return [];
+
+  const categoriesArray = Array.isArray(categories) ? categories : categories.split(',');
+
+  return [
+    {
+      $match: {
+        'products.category': { $in: categoriesArray.map(id => new ObjectId(id)) },
+      },
+    },
+  ];
+};
+
+/**
+ * Get contain conditions (spots must have availability, products, etc)
+ */
+const getContainConditions = contain => {
+  if (!contain) return [];
+
+  const conditions = contain.map(property => ({
+    [property]: { $exists: true, $not: { $size: 0 } },
+  }));
+
+  return conditions.length > 0 ? [{ $match: { $and: conditions } }] : [];
+};
+
+/**
+ * Геофильтрация для Spots (адаптировано из organizations)
+ */
+const hasLocationParams = query => query.location || query.address || query.city || query.state || query.country;
+
+const resolveLocation = async query => {
+  if (query.location) {
+    const parsedLocation = typeof query.location === 'string' ? JSON.parse(query.location) : query.location;
+    const coordinates = parsedLocation.lng ? [parsedLocation.lng, parsedLocation.lat] : parsedLocation.coordinates;
+    return { coordinates: coordinates.map(coord => parseFloat(coord)) };
+  }
+  const searchString = [query.address, query.city, query.state, query.country].filter(Boolean).join(', ');
+  try {
+    const geoResponse = await client.geocode({
+      params: {
+        address: searchString,
+        key: process.env.GOOGLE_MAPS_API_KEY,
+      },
+    });
+    if (!geoResponse.data.results?.length) {
+      throw new Error('Unable to geocode the provided location.');
+    }
+    const { lng, lat } = geoResponse.data.results[0].geometry.location;
+    return { coordinates: [lng, lat] };
+  } catch (err) {
+    throw new Error('Error occurred while geocoding.');
+  }
+};
+
+const getRadius = query => {
+  if (query.locationRadius) return parseFloat(query.locationRadius) / 6378.1;
+  if (query.city) return 25 / 6378.1;
+  if (query.state) return 50 / 6378.1;
+  return null;
+};
+
+const getDistanceStages = location => [
+  {
+    $addFields: {
+      distance: {
+        $function: {
+          body: `function(spotCoords, userCoords, isMiles) {
+            function toRad(x) {
+              return x * Math.PI / 180;
+            }
+            var lon1 = spotCoords[0];
+            var lat1 = spotCoords[1];
+            var lon2 = userCoords[0];
+            var lat2 = userCoords[1];
+            var R = 6371;
+            if (isMiles) R = 3959;
+            var x1 = lat2 - lat1;
+            var dLat = toRad(x1);
+            var x2 = lon2 - lon1;
+            var dLon = toRad(x2);
+            var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+                    Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) *
+                    Math.sin(dLon / 2) * Math.sin(dLon / 2);
+            var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+            var d = R * c;
+            return d;
+          }`,
+          args: ['$location.coordinates', location.coordinates, false],
+          lang: 'js',
+        },
+      },
+    },
+  },
+];
+
+const getSpotsLocationStages = async query => {
+  if (!hasLocationParams(query)) {
+    return { stages: [], userLocation: null };
+  }
+  const location = await resolveLocation(query);
+  const radius = getRadius(query);
+  const geoStages = radius
+    ? [
+        {
+          $match: {
+            'location.coordinates': {
+              $geoWithin: {
+                $centerSphere: [[location.coordinates[0], location.coordinates[1]], radius],
+              },
+            },
+          },
+        },
+      ]
+    : [];
+  return {
+    stages: [...geoStages, ...getDistanceStages(location)],
+    userLocation: location,
+  };
+};
+
+export {
+  getBasicMatchConditions,
+  getPriceConditions,
+  getCategoryConditions,
+  getContainConditions,
+  getSpotsLocationStages,
+};
+
+export default {
+  getBasicMatchConditions,
+  getPriceConditions,
+  getCategoryConditions,
+  getContainConditions,
+  getSpotsLocationStages,
+};