@ozdao/martyrs 0.2.506 → 0.2.507

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

@@ -0,0 +1,251 @@
+import Validator from '@martyrs/src/modules/globals/controllers/classes/globals.validator.js';
+import Verifier from '@martyrs/src/modules/globals/controllers/classes/globals.verifier.js';
+
+export default (function (db) {
+
+  // Верификатор для создания
+  const createVerifier = new Verifier({
+    email: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .email('Invalid email format')
+        .max(255, 'Email must not exceed 255 characters')
+    },
+    phone: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .pattern(/^\+?[1-9]\d{1,14}$/, 'Invalid phone format')
+    },
+    'profile.name': {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .min(1, 'Name must be at least 1 character')
+        .max(255, 'Name must not exceed 255 characters')
+    },
+    'profile.description': {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .max(1000, 'Description must not exceed 1000 characters')
+    },
+    'profile.photo': {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .max(500, 'Photo URL must not exceed 500 characters')
+    },
+    source: {
+      rule: 'optional',
+      default: 'web',
+      validator: Validator.schema()
+        .string()
+        .oneOf(['web', 'mobile', 'api', 'import', 'manual', 'referral', 'social', 'email'])
+    },
+    'referral.code': {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .max(50, 'Referral code must not exceed 50 characters')
+    },
+    'referral.source': {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .pattern(/^[0-9a-fA-F]{24}$/, 'Invalid referral source ID format')
+    },
+    tags: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .array()
+        .items(Validator.schema().string().max(50))
+        .max(20, 'Cannot have more than 20 tags')
+    },
+    notes: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .max(2000, 'Notes must not exceed 2000 characters')
+    },
+    status: {
+      rule: 'optional',
+      default: 'active',
+      validator: Validator.schema()
+        .string()
+        .oneOf(['active', 'inactive', 'blocked'])
+    },
+    'identity.type': {
+      rule: 'required',
+      validator: Validator.schema()
+        .string()
+        .oneOf(['Visitor', 'User', 'Organization'])
+    },
+    'identity.target': {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .pattern(/^[0-9a-fA-F]{24}$/, 'Invalid identity target ID format')
+    },
+    owner: {
+      rule: 'required',
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(['user', 'organization', 'User', 'Organization']),
+        target: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      })
+    }
+  });
+
+  // Верификатор для обновления
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: 'required',
+      validator: Validator.schema()
+        .string()
+        .required('Customer ID is required')
+        .pattern(/^[0-9a-fA-F]{24}$/, 'Invalid ID format')
+    },
+    email: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .email('Invalid email format')
+        .max(255, 'Email must not exceed 255 characters')
+    },
+    phone: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .pattern(/^\+?[1-9]\d{1,14}$/, 'Invalid phone format')
+    },
+    'profile.name': {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .min(1, 'Name must be at least 1 character')
+        .max(255, 'Name must not exceed 255 characters')
+    },
+    'profile.description': {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .max(1000, 'Description must not exceed 1000 characters')
+    },
+    'profile.photo': {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .max(500, 'Photo URL must not exceed 500 characters')
+    },
+    source: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .oneOf(['web', 'mobile', 'api', 'import', 'manual', 'referral', 'social', 'email'])
+    },
+    'referral.code': {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .max(50, 'Referral code must not exceed 50 characters')
+    },
+    'referral.source': {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .pattern(/^[0-9a-fA-F]{24}$/, 'Invalid referral source ID format')
+    },
+    tags: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .array()
+        .items(Validator.schema().string().max(50))
+        .max(20, 'Cannot have more than 20 tags')
+    },
+    notes: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .max(2000, 'Notes must not exceed 2000 characters')
+    },
+    status: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .oneOf(['active', 'inactive', 'blocked'])
+    }
+  });
+
+  // Верификатор для чтения
+  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(['active', 'inactive', 'blocked'])
+    },
+    source: {
+      rule: 'optional',
+      validator: Validator.schema()
+        .string()
+        .oneOf(['web', 'mobile', 'api', 'import', 'manual', 'referral', 'social', 'email'])
+    },
+    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(['profile.name', 'email', 'phone', 'lastActivity', 'createdAt', 'updatedAt'])
+    },
+    sortOrder: {
+      rule: 'optional',
+      default: 'desc',
+      validator: Validator.schema()
+        .string()
+        .oneOf(['asc', 'desc'])
+    }
+  });
+
+  // Верификатор для удаления
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: 'required',
+      validator: Validator.schema()
+        .string()
+        .required('Customer ID is required')
+        .pattern(/^[0-9a-fA-F]{24}$/)
+    }
+  });
+
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+});

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

@@ -1,3 +1,5 @@
+import applyOwnershipSchema from '@martyrs/src/modules/globals/models/schemas/ownership.schema.js';
+
 export default db => {
   const ApplicationSchema = new db.mongoose.Schema(
     {
@@ -20,11 +22,30 @@ export default db => {
           type: String,
         },
       },
+      text: {
+        type: String,
+      },
+      chat: {
+        type: String,
+      },
+      customer: {
+        type: {
+          type: String,
+          enum: ['Customer'],
+        },
+        target: {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: 'Customer',
+        },
+      },
     },
     {
       timestamps: { currentTime: () => Date.now() },
     }
   );
+
+  applyOwnershipSchema(ApplicationSchema, db);
+
   const Application = db.mongoose.model('Application', ApplicationSchema);
   return Application;
 };

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

@@ -16,10 +16,34 @@ export default db => {
           refPath: 'target.type',
         },
       },
+      source: {
+        type: String,
+        enum: ['web', 'mobile', 'api', 'import', 'manual', 'referral', 'social', 'email'],
+        default: 'web',
+      },
       referral: {
         code: {
           type: String,
         },
+        source: {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: 'Customer',
+        },
+      },
+      tags: [{
+        type: String,
+      }],
+      notes: {
+        type: String,
+      },
+      lastActivity: {
+        type: Date,
+        default: Date.now,
+      },
+      status: {
+        type: String,
+        enum: ['active', 'inactive', 'blocked'],
+        default: 'active',
       },
     },
     {
@@ -31,6 +55,8 @@ export default db => {
   applyCredentialsSchema(CustomerSchema, db);
   applyProfileSchema(CustomerSchema, db);
   applyOwnershipSchema(CustomerSchema, db);
+ 
+
   CustomerSchema.index(
     {
       owner: 1,

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

@@ -2,31 +2,43 @@
 import * as storeOrders from './store/orders.js';
 import * as storeShopcart from './store/shopcart.js';
 import * as storeTestimonials from './store/testimonials.js';
+import storeCustomers from './store/customers.store.js';
+import storeApplications from './store/applications.js';
 // Router
 import addRoutes from '@martyrs/src/modules/globals/views/router/addRoutes.js';
 import routerOrders from './router/orders.router.js';
+import routerCustomers from './router/customers.router.js';
+import routerApplications from './router/applications.router.js';
 // Views
 import OrderCreate from './components/pages/OrderCreate.vue';
 import OrderCreateBackoffice from './components/pages/OrderCreateBackoffice.vue';
 import Orders from './components/pages/Orders.vue';
+import Customers from './components/pages/Customers.vue';
+import Applications from './components/pages/Applications.vue';
 // import Favorites from './components/pages/Favorites.vue';
 // Importing blocks components
 import CardOrder from './components/blocks/CardOrder.vue';
 import CardOrderItem from './components/blocks/CardOrderItem.vue';
 import CardOrderUser from './components/blocks/CardOrderUser.vue';
+import CardCustomer from './components/blocks/CardCustomer.vue';
 import StatusHistory from './components/blocks/StatusHistory.vue';
 // Importing sections components
 import AskToLogin from './components/sections/AskToLogin.vue';
 import EmptyState from './components/sections/EmptyState.vue';
-import FormCustomerDetails from './components/sections/FormCustomerDetails.vue';
+import FormCustomerDetails from './components/forms/FormCustomerDetails.vue';
 import FormDelivery from './components/sections/FormDelivery.vue';
 import FormPayment from './components/sections/FormPayment.vue';
 import Succes from './components/sections/Succes.vue';
 // Importing partials components
 import ShopCart from './components/partials/ShopCart.vue';
 
+import { i18nManager } from '@martyrs/src/modules/globals/views/classes/globals.i18n.js';
+import locales from './locales/index.js';
+
 // Пример функции инициализации для модуля заказов
 function initializeOrders(app, store, router, options = {}) {
+  // Регистрируем локализацию для модуля orders
+  i18nManager.register('orders', locales);
   const route = options.route || 'Home';
   const routeBackoffice = options.routeBackoffice || 'Backoffice Root';
   const routeOrganizations = options.routeOrganizations || 'OrganizationRoot';
@@ -99,9 +111,75 @@ function initializeOrders(app, store, router, options = {}) {
     console.log('Route keys:', orgOrdersList?.keys);
   }
 
+  // Customer routes for backoffice
+  if (!options.withBackoffice) {
+    addRoutes(router, {
+      parentName: routeBackoffice,
+      basePath: 'customers',
+      routes: routerCustomers,
+      routeNamePrefix: 'Backoffice',
+      filterConfig: {
+        include: ['CustomersList'],
+      },
+      meta: {
+        context: 'backoffice',
+      },
+    });
+  }
+
+  // Customer routes for organizations
+  if (!options.withOrganizationRoutes) {
+    addRoutes(router, {
+      parentName: routeOrganizations,
+      basePath: 'customers',
+      routes: routerCustomers,
+      routeNamePrefix: 'Organization',
+      filterConfig: {
+        include: ['CustomersList'],
+      },
+      meta: {
+        context: 'organization',
+      },
+    });
+  }
+
+  // Application routes for backoffice
+  if (!options.withBackoffice) {
+    addRoutes(router, {
+      parentName: routeBackoffice,
+      basePath: 'applications',
+      routes: routerApplications,
+      routeNamePrefix: 'Backoffice',
+      filterConfig: {
+        include: ['Applications'],
+      },
+      meta: {
+        context: 'backoffice',
+      },
+    });
+  }
+
+  // Application routes for organizations
+  if (!options.withOrganizationRoutes) {
+    addRoutes(router, {
+      parentName: routeOrganizations,
+      basePath: 'applications',
+      routes: routerApplications,
+      routeNamePrefix: 'Organization',
+      filterConfig: {
+        include: ['Applications'],
+      },
+      meta: {
+        context: 'organization',
+      },
+    });
+  }
+
   store.addStore('orders', storeOrders);
   store.addStore('shopcart', storeShopcart);
   store.addStore('testimonials', storeTestimonials);
+  store.addStore('customers', storeCustomers);
+  store.addStore('applications', storeApplications);
 }
 
 const ModuleOrder = {
@@ -111,13 +189,19 @@ const ModuleOrder = {
       storeOrders,
       storeShopcart,
       storeTestimonials,
+      storeCustomers,
+      storeApplications,
     },
     router: {
       routerOrders,
+      routerCustomers,
+      routerApplications,
     },
     components: {
       // Pages
       Orders,
+      Customers,
+      Applications,
       // Order,
       OrderCreate,
       OrderCreateBackoffice,
@@ -126,6 +210,7 @@ const ModuleOrder = {
       CardOrderItem,
       CardOrder,
       CardOrderUser,
+      CardCustomer,
       StatusHistory,
       // Sections
       FormCustomerDetails,

package/src/modules/orders/orders.server.js

@@ -6,6 +6,7 @@ import ModelOrder from './models/order.model.js';
 import ModelTestimonial from './models/testimonial.model.js';
 import RoutesApplications from './routes/applications.routes.js';
 import RoutesOrder from './routes/orders.routes.js';
+import RoutesCustomers from './routes/customers.routes.js';
 function initializeOrders(app, db, origins, publicPath) {
   // Setup models in the database object
   db.order = ModelOrder(db);
@@ -16,7 +17,7 @@ function initializeOrders(app, db, origins, publicPath) {
   if (app) {
     RoutesOrder(app, db, origins, publicPath);
     RoutesApplications(app, db, origins, publicPath);
-    new CRUD('/api/customers', app, db, db.customer);
+    RoutesCustomers(app, db);
   }
 }
 export const models = {
@@ -25,6 +26,7 @@ export const models = {
 };
 export const routes = {
   RoutesOrder,
+  RoutesCustomers,
 };
 export const controllers = {
   FactoryOrder,

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

@@ -0,0 +1,15 @@
+const applicationsRoutes = [
+  {
+    path: '',
+    name: 'Applications', 
+    component: () => import('@martyrs/src/modules/orders/components/pages/Applications.vue'),
+    meta: {
+      title: {
+        en: 'Applications',
+        ru: 'Заявки',
+      },
+    },
+  },
+];
+
+export default applicationsRoutes;

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

@@ -0,0 +1,17 @@
+import Customers from '@martyrs/src/modules/orders/components/pages/Customers.vue';
+
+const customersRoutes = [
+  {
+    path: '',
+    name: 'CustomersList',
+    component: Customers,
+    meta: {
+      title: {
+        en: 'Customers',
+        ru: 'Клиенты',
+      },
+    },
+  },
+];
+
+export default customersRoutes;

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

@@ -1,12 +1,124 @@
-import middlewareFactoryAuth from '@martyrs/src/modules/auth/controllers/middlewares/index.js';
-import controllerFactory from '../controllers/applications.controller.js';
-export default (function (app, db, origins) {
-  const controller = controllerFactory(db);
-  const { authJwt } = middlewareFactoryAuth(db);
-  app.post('/applications', controller.create);
-  app.get('/applications', controller.read);
-  app.post('/applications/:_id', controller.update);
-  app.delete('/applications/:_id', controller.delete);
-  app.get('/applications/:_id', controller.get);
-  app.post('/applications/telegram-webhook', controller.handleTelegramWebhook);
-});
+import CRUD from '@martyrs/src/modules/globals/controllers/classes/crud/crud.js';
+import ABAC from '@martyrs/src/modules/globals/controllers/classes/abac/abac.js';
+import mailing from '@martyrs/src/modules/globals/controllers/utils/mailing.js';
+import axios from 'axios';
+
+import verifierFactory from '../middlewares/applications.verifier.js';
+
+const { getInstance } = ABAC;
+
+export default function setupApplicationsRoutes(app, db) {
+  const abac = getInstance(db);
+  const verifier = verifierFactory(db);
+
+  const applicationsCRUD = new CRUD({
+    app,
+    db,
+    model: db.application,
+    modelName: 'application',
+    basePath: '/api/applications',
+
+    auth: true, 
+
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    
+    abac: abac,
+    
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ['application', 'orders']
+    },
+    
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+
+  // Добавляем кастомный роут для телеграм вебхука
+  applicationsCRUD.addAction('telegram-webhook', {
+    method: 'post',
+    path: '/telegram-webhook',
+    auth: false,
+    abac: { enabled: false },
+    handler: async (req, res) => {
+      const update = req.body;
+      
+      if (update.callback_query) {
+        const callbackQuery = update.callback_query;
+        const callbackData = callbackQuery.data;
+        const [action, applicationId] = callbackData.split('_');
+        
+        try {
+          let updatedApplication = null;
+          switch (action) {
+            case 'confirm':
+              updatedApplication = await db.application.findOneAndUpdate({ _id: applicationId }, { status: 'confirmed' }, { new: true });
+              break;
+            case 'lost':
+              updatedApplication = await db.application.findOneAndUpdate({ _id: applicationId }, { status: 'lost' }, { new: true });
+              break;
+            case 'delete':
+              updatedApplication = await db.application.findOneAndDelete({ _id: applicationId });
+              break;
+          }
+          
+          if (!updatedApplication) {
+            console.log('Application not found or not updated.');
+          } else {
+            console.log('Application updated:', updatedApplication);
+          }
+        } catch (err) {
+          console.log('Error updating application:', err);
+        }
+        
+        const queryId = callbackQuery.id;
+        const telegramToken = '6206215053:AAHYCYzpFZF9jDZC-TC03NSff8oo2ExqsSU';
+        axios.post(`https://api.telegram.org/bot${telegramToken}/answerCallbackQuery`, {
+          callback_query_id: queryId,
+        });
+      }
+      
+      res.sendStatus(200);
+    }
+  });
+
+  // Добавляем публичный роут для создания заявок пользователями
+  applicationsCRUD.addAction('public-create', {
+    method: 'post',
+    path: '/public',
+    auth: false,
+    abac: { enabled: false },
+    handler: async (req, res) => {
+      try {
+        const applicationData = {
+          ...req.body,
+          owner: {
+            type: 'platform',
+            target: '000000000000000000000000' // заглушка для отдела платформы
+          },
+          creator: {
+            type: 'platform',
+            target: '000000000000000000000000'
+          }
+        };
+
+        const application = new db.application(applicationData);
+        const saved = await application.save();
+        
+        res.status(201).json(saved);
+      } catch (error) {
+        console.error('Error creating public application:', error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  return applicationsCRUD;
+}