@ozdao/martyrs 0.2.603 → 0.2.605

package/src/modules/orders/middlewares/applications.verifier.js

@@ -37,7 +37,7 @@ export default (function (db) {
       default: 'created',
       validator: Validator.schema()
         .string()
-        .oneOf(['created', 'in_progress', 'completed', 'cancelled'])
+        .oneOf(['created', 'in_progress', 'completed', 'canceled'])
     },
     owner: {
       rule: 'optional',
@@ -87,7 +87,7 @@ export default (function (db) {
       rule: 'optional',
       validator: Validator.schema()
         .string()
-        .oneOf(['created', 'in_progress', 'completed', 'cancelled'])
+        .oneOf(['created', 'in_progress', 'completed', 'canceled'])
     }
   });
 
@@ -107,7 +107,7 @@ export default (function (db) {
       rule: 'optional',
       validator: Validator.schema()
         .string()
-        .oneOf(['created', 'in_progress', 'completed', 'cancelled'])
+        .oneOf(['created', 'in_progress', 'completed', 'canceled'])
     },
     type: {
       rule: 'optional',

package/src/modules/orders/middlewares/customers.verifier.js

@@ -168,6 +168,10 @@ export default (function (db) {
         .string()
         .pattern(/^[0-9a-fA-F]{24}$/)
     },
+    search: {
+      rule: 'optional',
+      validator: Validator.schema().string().max(255)
+    },
     owner: {
       rule: 'optional',
       validator: Validator.schema().string()

package/src/modules/orders/middlewares/orders.verifier.js

@@ -0,0 +1,187 @@
+import Validator from '@martyrs/src/modules/core/controllers/classes/core.validator.js';
+import Verifier from '@martyrs/src/modules/core/controllers/classes/core.verifier.js';
+
+export default (function (db) {
+
+  // Верификатор для создания заказа
+  const createVerifier = new Verifier({
+    positions: {
+      rule: 'required',
+      validator: Validator.schema()
+        .array()
+        .min(1, 'At least one position is required')
+    },
+    owner: {
+      rule: 'required',
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(['user', 'organization', 'User', 'Organization']).required(),
+        target: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/).required()
+      })
+    },
+    customer: {
+      rule: 'optional',
+    },
+    delivery: {
+      rule: 'optional',
+    },
+    payment: {
+      rule: 'optional',
+    },
+    comment: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .max(2000, 'Comment must not exceed 2000 characters')
+    }
+  });
+
+  // Верификатор для чтения заказов
+  const readVerifier = new Verifier({
+    _id: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .pattern(/^[0-9a-fA-F]{24}$/)
+    },
+    owner: {
+      rule: 'optional',
+      validator: Validator.schema().string()
+    },
+    status: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .oneOf(['created', 'confirmed', 'processing', 'ready', 'delivering', 'completed', 'canceled', 'closed'])
+    },
+    skip: {
+      rule: 'optional',
+      default: 0,
+      validator: Validator.schema()
+        .integer()
+        .min(0)
+    },
+    limit: {
+      rule: 'optional',
+      default: 20,
+      validator: Validator.schema()
+        .integer()
+        .min(1)
+        .max(100)
+    },
+    sortParam: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .oneOf(['createdAt', 'updatedAt', 'totalPrice', 'status'])
+    },
+    sortOrder: {
+      rule: 'optional',
+      default: 'desc',
+      validator: Validator.schema()
+        .string()
+        .oneOf(['asc', 'desc'])
+    },
+    dateStart: {
+      rule: 'optional',
+      validator: Validator.schema().string()
+    },
+    dateEnd: {
+      rule: 'optional',
+      validator: Validator.schema().string()
+    },
+    search: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .max(255)
+    }
+  });
+
+  // Верификатор для обновления заказа
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: 'required',
+      validator: Validator.schema()
+        .string()
+        .required('Order ID is required')
+        .pattern(/^[0-9a-fA-F]{24}$/, 'Invalid ID format')
+    },
+    status: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .oneOf(['created', 'confirmed', 'processing', 'ready', 'delivering', 'completed', 'canceled', 'closed'])
+    },
+    positions: {
+      rule: 'optional',
+      validator: Validator.schema().array()
+    },
+    payment: {
+      rule: 'optional',
+    },
+    comment: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .max(2000, 'Comment must not exceed 2000 characters')
+    }
+  });
+
+  // Верификатор для удаления заказа
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: 'required',
+      validator: Validator.schema()
+        .string()
+        .required('Order ID is required')
+        .pattern(/^[0-9a-fA-F]{24}$/)
+    }
+  });
+
+  return {
+    verifyCreate(req, res, next) {
+      const verification = createVerifier.verify(req.body);
+      if (!verification.isValid) {
+        return res.status(400).json({
+          errors: verification.verificationErrors,
+          message: 'Invalid request data',
+        });
+      }
+      req.verifiedBody = verification.verifiedData;
+      next();
+    },
+    verifyRead(req, res, next) {
+      const verification = readVerifier.verify(req.query);
+      if (!verification.isValid) {
+        return res.status(400).json({
+          errors: verification.verificationErrors,
+          message: 'Invalid query parameters',
+        });
+      }
+      req.verifiedQuery = verification.verifiedData;
+      next();
+    },
+    verifyUpdate(req, res, next) {
+      const verification = updateVerifier.verify(req.body);
+      if (!verification.isValid) {
+        return res.status(400).json({
+          errors: verification.verificationErrors,
+          message: 'Invalid request data',
+        });
+      }
+      req.verifiedBody = verification.verifiedData;
+      next();
+    },
+    verifyDelete(req, res, next) {
+      const verification = deleteVerifier.verify(req.body);
+      if (!verification.isValid) {
+        return res.status(400).json({
+          errors: verification.verificationErrors,
+          message: 'Invalid request data',
+        });
+      }
+      req.verifiedBody = verification.verifiedData;
+      next();
+    }
+  };
+});

package/src/modules/orders/models/customer.model.js

@@ -1,6 +1,7 @@
 import applyCredentialsSchema from '@martyrs/src/modules/core/models/schemas/credentials.schema.js';
 import applyOwnershipSchema from '@martyrs/src/modules/core/models/schemas/ownership.schema.js';
 import applyProfileSchema from '@martyrs/src/modules/core/models/schemas/profile.schema.js';
+import applySocialsSchema from '@martyrs/src/modules/core/models/schemas/socials.schema.js';
 export default db => {
   const CustomerSchema = new db.mongoose.Schema(
     {
@@ -72,6 +73,7 @@ export default db => {
   applyCredentialsSchema(CustomerSchema, db);
   applyProfileSchema(CustomerSchema, db);
   applyOwnershipSchema(CustomerSchema, db);
+  applySocialsSchema(CustomerSchema, db);
  
 
   CustomerSchema.index(

package/src/modules/orders/models/order.model.js

@@ -13,8 +13,26 @@ export default db => {
           required: true,
         },
       },
-      positions: {
-        type: Array,
+      positions: [{
+        _id: { type: db.mongoose.Schema.Types.ObjectId, ref: 'Product' },
+        variant: { type: db.mongoose.Schema.Types.ObjectId, ref: 'Variant', default: null },
+        name: { type: String },
+        images: { type: Array },
+        listing: { type: String, enum: ['sale', 'rent'] },
+        rentPeriod: { type: String, enum: ['hour', '4hours', 'flat', 'day', 'week', 'month'], default: 'day' },
+        price: { type: Number },
+        cost: { type: Number, default: 0 },
+        quantity: { type: Number, default: 1 },
+        unit: { type: String },
+        date: {
+          start: { type: Date },
+          end: { type: Date },
+        },
+        totalPrice: { type: Number, default: 0 },
+      }],
+      totalPrice: {
+        type: Number,
+        default: 0,
       },
       referralCode: {
         type: String,

package/src/modules/orders/orders.client.js

@@ -46,21 +46,23 @@ function initializeOrders(app, store, router, options = {}) {
 
   if (typeof window !== 'undefined') storeShopcart.actions.setShopcart()
 
-  addRoutes(router, {
-    parentName: route,
-    basePath: 'orders',
-    routes: routerOrders,
-    routeNamePrefix: '',
-    filterConfig: {
-      include: ['CreateOrder', 'Order'], // Только создание заказа на корневом уровне
-    },
-    meta: {
-      context: 'root',
-    },
-  });
+  if (!options.contexts || options.contexts.includes('client')) {
+    addRoutes(router, {
+      parentName: route,
+      basePath: 'orders',
+      routes: routerOrders,
+      routeNamePrefix: '',
+      filterConfig: {
+        include: ['CreateOrder', 'Order'], // Только создание заказа на корневом уровне
+      },
+      meta: {
+        context: 'root',
+      },
+    });
+  }
 
   // Backoffice routes
-  if (!options.withBackoffice) {
+  if (!options.contexts || options.contexts.includes('backoffice')) {
     addRoutes(router, {
       parentName: routeBackoffice,
       basePath: 'orders', // Промежуточный маршрут /backoffice/orders
@@ -76,7 +78,7 @@ function initializeOrders(app, store, router, options = {}) {
   }
 
   // User routes
-  if (!options.withUserRoutes) {
+  if (!options.contexts || options.contexts.includes('user')) {
     addRoutes(router, {
       parentName: routeUsers,
       basePath: 'orders', // Промежуточный маршрут /user/orders
@@ -92,7 +94,7 @@ function initializeOrders(app, store, router, options = {}) {
   }
 
   // Organization routes
-  if (!options.withOrganizationRoutes) {
+  if (!options.contexts || options.contexts.includes('organization')) {
     addRoutes(router, {
       parentName: routeOrganizations,
       basePath: 'orders', // Промежуточный маршрут /organization/orders
@@ -108,7 +110,7 @@ function initializeOrders(app, store, router, options = {}) {
   }
 
   // Customer routes for backoffice
-  if (!options.withBackoffice) {
+  if (!options.contexts || options.contexts.includes('backoffice')) {
     addRoutes(router, {
       parentName: routeBackoffice,
       basePath: 'customers',
@@ -124,7 +126,7 @@ function initializeOrders(app, store, router, options = {}) {
   }
 
   // Customer routes for organizations
-  if (!options.withOrganizationRoutes) {
+  if (!options.contexts || options.contexts.includes('organization')) {
     addRoutes(router, {
       parentName: routeOrganizations,
       basePath: 'customers',
@@ -140,7 +142,7 @@ function initializeOrders(app, store, router, options = {}) {
   }
 
   // Application routes for backoffice
-  if (!options.withBackoffice) {
+  if (!options.contexts || options.contexts.includes('backoffice')) {
     addRoutes(router, {
       parentName: routeBackoffice,
       basePath: 'applications',
@@ -156,7 +158,7 @@ function initializeOrders(app, store, router, options = {}) {
   }
 
   // Application routes for organizations
-  if (!options.withOrganizationRoutes) {
+  if (!options.contexts || options.contexts.includes('organization')) {
     addRoutes(router, {
       parentName: routeOrganizations,
       basePath: 'applications',

package/src/modules/orders/routes/applications.routes.js

@@ -23,7 +23,18 @@ export default function setupApplicationsRoutes(app, db) {
       { $project: { userId: '$_id' }}
     ];
     const result = await db.department.aggregate(pipeline);
-    return result.map(item => item.userId);
+    let userIds = result.map(item => item.userId);
+
+    // Фоллбэк: если нет участников в отделах — отправляем owner организации
+    if (userIds.length === 0) {
+      const org = await db.organization.findById(organizationId, { owner: 1 }).lean();
+      if (org?.owner) {
+        userIds = [org.owner];
+        console.log('Applications: fallback to org owner:', org.owner);
+      }
+    }
+
+    return userIds;
   };
 
   const sendApplicationNotifications = async (application, userIds) => {
@@ -167,8 +178,7 @@ export default function setupApplicationsRoutes(app, db) {
 
         const saved = await applicationsCRUD.service.create(applicationData);
 
-        // Push notifications
-        notifyApplicationCreated(saved).catch(console.error);
+        // Push notifications handled by afterCreate hook
 
         res.status(201).json(saved);
       } catch (error) {

package/src/modules/orders/routes/customers.routes.js

@@ -27,6 +27,8 @@ export default function setupCustomersRoutes(app, db) {
     
     abac: abac,
     
+    searchFields: ['profile.name', 'phone', 'email'],
+
     cache: {
       enabled: true,
       ttl: 300,

package/src/modules/orders/routes/orders.routes.js

@@ -1,24 +1,35 @@
 import middlewareFactoryAuth from '@martyrs/src/modules/auth/controllers/middlewares/index.js';
 import controllerFactory from '../controllers/orders.controller.js';
+import verifierFactory from '../middlewares/orders.verifier.js';
 import ABAC from '@martyrs/src/modules/core/controllers/classes/abac/abac.js';
 const { getInstance } = ABAC;
 export default (function (app, db, origins, publicPath) {
   const controller = controllerFactory(db);
   const middleware = middlewareFactoryAuth(db);
   const abac = getInstance(db);
+  const verifier = verifierFactory(db);
   app.post(
     '/api/orders/create',
     [
-      middleware.authJwt.verifyToken(true)
+      middleware.authJwt.verifyToken(true),
+      verifier.verifyCreate
     ],
     controller.create
   );
   app.get('/api/orders/read',
     [
-      middleware.authJwt.verifyToken(true)
+      middleware.authJwt.verifyToken(),
+      abac.middleware('orders', 'read'),
+      verifier.verifyRead
     ],
     controller.read
   );
+  app.get('/api/orders/my',
+    [
+      middleware.authJwt.verifyToken(true)
+    ],
+    controller.readMy
+  );
   app.get('/api/orders/stats',
     middleware.authJwt.verifyToken(),
     abac.middleware('orders', 'read'),
@@ -27,15 +38,46 @@ export default (function (app, db, origins, publicPath) {
   app.post(
     '/api/orders/update',
     [
-      middleware.authJwt.verifyToken()
+      middleware.authJwt.verifyToken(),
+      abac.middleware('orders', 'confirm'),
+      verifier.verifyUpdate
     ],
     controller.update
   );
   app.post(
     '/api/orders/delete',
     [
-      middleware.authJwt.verifyToken()
+      middleware.authJwt.verifyToken(),
+      abac.middleware('orders', 'delete'),
+      verifier.verifyDelete
     ],
     controller.deleteOrder
   );
+
+  // Internal endpoint for Telegram callback actions (confirm/cancel via bot buttons)
+  app.post(
+    '/api/orders/telegram-action',
+    [
+      middleware.authJwt.verifyToken(), // X-Service-Key bypass
+    ],
+    async (req, res) => {
+      try {
+        const { action, orderId } = req.body;
+        if (!action || !orderId) {
+          return res.status(400).json({ message: 'action and orderId are required' });
+        }
+        if (!['confirm', 'cancel'].includes(action)) {
+          return res.status(400).json({ message: 'action must be confirm or cancel' });
+        }
+        const result = await controller.handleTelegramAction(action, orderId);
+        if (!result.success) {
+          return res.status(400).json(result);
+        }
+        return res.status(200).json(result);
+      } catch (err) {
+        console.error('[Telegram Action] Error:', err);
+        return res.status(500).json({ message: 'Internal error' });
+      }
+    }
+  );
 });

package/src/modules/orders/store/orders.js

@@ -6,6 +6,8 @@ import $axios from '@martyrs/src/modules/core/views/utils/axios-instance.js';
 import { setError } from '@martyrs/src/modules/core/views/store/core.store.js';
 // Init State
 import orderInitState from '@martyrs/src/modules/orders/store/models/order.js';
+// Rent price utils
+import { calcRentTotalPrice } from '@martyrs/src/modules/orders/utils/rent-price.js';
 
 const state = reactive({
   all: [],
@@ -160,14 +162,9 @@ const getters = {
   getTotal(positions) {
     return Number(
       positions.reduce((total, product) => {
-        // Проверяем тип листинга
-        if (product.listing === 'rent') {
-          const start = new Date(product.date.start);
-          const end = new Date(product.date.end);
-          const diffTime = Math.abs(end - start);
-          return total + product.price * (Math.ceil(diffTime / (1000 * 60 * 60 * 24)) + 1);
+        if (product.listing === 'rent' && product.date?.start && product.date?.end) {
+          return total + calcRentTotalPrice(product.price, product.quantity, product.date.start, product.date.end, product.rentPeriod || 'day');
         } else {
-          // Для обычных товаров умножаем на количество
           return total + product.price * (product.quantity || 1);
         }
       }, 0)

package/src/modules/orders/store/shopcart.js

@@ -7,6 +7,8 @@ import { computed, reactive, watch } from 'vue';
 import { setError, setSnack } from '@martyrs/src/modules/core/views/store/core.store.js';
 // Capacitor Preferences
 import { Preferences } from '@capacitor/preferences';
+// Rent price utils
+import { calcRentTotalPrice } from '@martyrs/src/modules/orders/utils/rent-price.js';
 
 /////////////////////////////
 // State
@@ -146,7 +148,9 @@ const actions = {
         images: variant.images?.length > 0 ? variant.images : product.images,
         name: product.name,
         listing: product.listing,
+        rentPeriod: product.rentPeriod || 'day',
         price: variant.price || product.price,
+        cost: variant.cost || 0,
         quantity: quantity,
         unit: variant.unit || product.unit,
         date: date,
@@ -240,14 +244,9 @@ const getters = {
   cartTotalPrice: computed(() => {
     return Number(
       state.positions.reduce((total, product) => {
-        // Проверяем тип листинга
-        if (product.listing === 'rent') {
-          const start = new Date(product.date.start);
-          const end = new Date(product.date.end);
-          const diffTime = Math.abs(end - start);
-          return total + product.price * (Math.ceil(diffTime / (1000 * 60 * 60 * 24)) + 1);
+        if (product.listing === 'rent' && product.date?.start && product.date?.end) {
+          return total + calcRentTotalPrice(product.price, product.quantity, product.date.start, product.date.end, product.rentPeriod || 'day');
         } else {
-          // Для обычных товаров умножаем на количество
           return total + product.price * (product.quantity || 1);
         }
       }, 0)

package/src/modules/orders/utils/rent-price.js

@@ -0,0 +1,90 @@
+/**
+ * Calculate rental duration periods count based on rentPeriod type
+ * @param {Date|string} start
+ * @param {Date|string} end
+ * @param {string} rentPeriod - 'hour' | '4hours' | 'flat' | 'day' | 'week' | 'month'
+ * @returns {number} number of periods (minimum 1)
+ */
+export function calcRentPeriods(start, end, rentPeriod = 'day') {
+  const s = new Date(start)
+  const e = new Date(end)
+  const diffMs = Math.abs(e - s)
+  const diffHours = diffMs / (1000 * 60 * 60)
+  const diffDays = diffMs / (1000 * 60 * 60 * 24)
+
+  switch (rentPeriod) {
+    case 'hour':
+      return Math.max(1, Math.ceil(diffHours))
+    case '4hours':
+      return Math.max(1, Math.ceil(diffHours / 4))
+    case 'flat':
+      return 1
+    case 'day':
+      return Math.max(1, Math.ceil(diffDays) + 1)
+    case 'week':
+      return Math.max(1, Math.ceil(diffDays / 7))
+    case 'month':
+      return Math.max(1, Math.ceil(diffDays / 30))
+    default:
+      return Math.max(1, Math.ceil(diffDays) + 1)
+  }
+}
+
+/**
+ * Calculate total rental price
+ * @param {number} pricePerPeriod
+ * @param {number} quantity
+ * @param {Date|string} start
+ * @param {Date|string} end
+ * @param {string} rentPeriod
+ * @returns {number}
+ */
+export function calcRentTotalPrice(pricePerPeriod, quantity, start, end, rentPeriod = 'day') {
+  const periods = calcRentPeriods(start, end, rentPeriod)
+  return pricePerPeriod * (quantity || 1) * periods
+}
+
+/**
+ * Format rent duration for display
+ * @param {Date|string} start
+ * @param {Date|string} end
+ * @param {string} rentPeriod
+ * @returns {string}
+ */
+/**
+ * Format rent date range label for display
+ * @param {Date|string} start
+ * @param {Date|string} end
+ * @param {string} rentPeriod
+ * @param {Function} formatDate - formatDate from useGlobalMixins
+ * @returns {string} e.g. "11 Mar – 14 Mar" or "11 Mar, 10:00 – 14:00"
+ */
+export function formatRentDateLabel(start, end, rentPeriod = 'day', formatDate) {
+  if (!start || !end) return ''
+  const isShortPeriod = ['hour', '4hours', 'flat'].includes(rentPeriod)
+  if (isShortPeriod) {
+    const s = new Date(start)
+    const e = new Date(end)
+    const dateStr = formatDate(s, { dayMonth: true })
+    const startTime = `${String(s.getHours()).padStart(2, '0')}:${String(s.getMinutes()).padStart(2, '0')}`
+    const endTime = `${String(e.getHours()).padStart(2, '0')}:${String(e.getMinutes()).padStart(2, '0')}`
+    return `${dateStr}, ${startTime} – ${endTime}`
+  }
+  return `${formatDate(start, { dayMonth: true })} – ${formatDate(end, { dayMonth: true })}`
+}
+
+export function formatRentDuration(start, end, rentPeriod = 'day') {
+  const periods = calcRentPeriods(start, end, rentPeriod)
+
+  const labels = {
+    hour: { one: 'hour', many: 'hours' },
+    '4hours': { one: '4 hours', many: '4 hours' },
+    'flat': { one: 'flat', many: 'flat' },
+    day: { one: 'day', many: 'days' },
+    week: { one: 'week', many: 'weeks' },
+    month: { one: 'month', many: 'months' },
+  }
+
+  const label = labels[rentPeriod] || labels.day
+  return `${periods} ${periods === 1 ? label.one : label.many}`
+}

package/src/modules/organizations/components/blocks/CardDepartment.vue

@@ -32,7 +32,7 @@ import IconEdit from '@martyrs/src/modules/icons/navigation/IconEdit.vue'
 
 import Spoiler  from '@martyrs/src/components/Spoiler/Spoiler.vue';
 import { DepartmentSub } from '@martyrs/src/modules/organizations/organizations.client.js';
-import User from '@martyrs/src/modules/auth/views/components/blocks/CardUser.vue';
+import User from '@martyrs/src/modules/core/views/components/blocks/CardUser.vue';
 
 const props = defineProps({
   department: Object,