@ozdao/martyrs 0.2.423

package/src/modules/community/router/blogposts.js

@@ -0,0 +1,72 @@
+import layoutCommunity from '../components/layouts/Community.vue'
+
+import * as validationAuth from '@martyrs/src/modules/auth/views/middlewares/auth.validation';
+import * as validationOwnership from '@martyrs/src/modules/auth/views/middlewares/ownership.validation';
+
+const community = {
+  path: 'community',
+  component: layoutCommunity,
+  meta: {
+    title: {
+      en: 'Community',
+      ru: 'Коммьюнити'
+    },
+    breadcrumbs: {
+      hidden: true
+    },
+    title_hide: true,
+  },
+  children: [{
+    path: ':category?',
+    name: 'Blog',
+    meta: {
+      title: {
+        en: 'Community',
+        ru: 'Коммьюнити'
+      },
+      title_hide: true,
+      hideNavigationBar: true
+    },
+    component: () => import(/* webpackChunkName: 'Blog' */ '../components/pages/Blog.vue')
+  },{
+    path: 'posts/create',
+    name: 'Create BlogPost',
+    meta: {
+      title: {
+        en: 'Create Post',
+        ru: 'Создать Пост'
+      },
+    },
+    beforeEnter: [
+      validationAuth.requiresAuth,
+    ],
+    component: () => import(/* webpackChunkName: 'CreateBlogPost' */ '../components/pages/CreateBlogPost.vue')
+  },{
+    path: 'posts/:url',
+    name: 'BlogPost',
+    meta: {
+      title: {
+        en: 'Post',
+        ru: 'Пост'
+      },
+      title_hide: false
+    },
+    component: () => import(/* webpackChunkName: 'BlogPost' */ '../components/pages/BlogPost.vue')
+  },{
+    path: 'posts/:url/edit',
+    name: 'Edit BlogPost',
+     meta: {
+      title: {
+        en: 'Edit Post',
+        ru: 'Редактировать пост'
+      },
+    },
+    beforeEnter: [
+      validationAuth.requiresAuth,
+      // validationOwnership.requiresEditAccess
+    ],
+    component: () => import(/* webpackChunkName: 'CreateBlogPost' */ '../components/pages/CreateBlogPost.vue')
+  }]
+}
+
+export default community;

package/src/modules/community/routes/blog.routes.js

@@ -0,0 +1,60 @@
+const controllerFactory = require("../controllers/blog.controller");
+
+const middlewareFactoryAuth = require('@martyrs/src/modules/auth/controllers/middlewares');
+const middlewareFactoryCommunity = require('../middlewares/server');
+
+// ABAC
+const { getInstance } = require('@martyrs/src/modules/globals/controllers/classes/globals.abac.js')
+
+
+module.exports = function(app, db, origins) {
+  const controller = controllerFactory(db);
+
+  const abac = getInstance(db);
+
+  const { authJwt } = middlewareFactoryAuth(db);
+  const { verifyBlogpost } = middlewareFactoryCommunity(db);
+
+  app.get(
+    "/api/blog/read",
+    [
+      authJwt.verifyToken(true),
+      abac.middleware('blogposts', 'read', { 
+        allowPublished: true, 
+        allowUnauthenticated: true 
+      })
+    ],
+    controller.read
+  );
+
+  app.post(
+    "/api/blog/create",
+    [
+      authJwt.verifyToken(),
+      abac.middleware('blogposts', 'create'),
+      verifyBlogpost.checkNameNotEmpty,
+      verifyBlogpost.checkBlogpostExistOrNot,
+    ],
+    controller.create
+  );
+
+  app.post(
+    "/api/blog/update",
+    [
+      authJwt.verifyToken(),
+      abac.middleware('blogposts', 'edit'),
+      verifyBlogpost.checkNameNotEmpty,
+      verifyBlogpost.checkBlogpostExistOrNot,
+    ],
+    controller.update
+  );
+
+  app.delete(
+    "/api/blog/delete/:_id",
+    [
+      authJwt.verifyToken(),
+      abac.middleware('blogposts', 'delete'),
+    ],
+    controller.delete
+  );
+};

package/src/modules/community/routes/comments.routes.js

@@ -0,0 +1,54 @@
+const controllerFactory = require("../controllers/comments.controller");
+
+const middlewareFactoryAuth = require('@martyrs/src/modules/auth/controllers/middlewares');
+// ABAC
+const { getInstance } = require('@martyrs/src/modules/globals/controllers/classes/globals.abac.js')
+
+
+
+module.exports = function(app, db) {
+  const controller = controllerFactory(db);
+
+  const abac = getInstance(db);
+  const { authJwt } = middlewareFactoryAuth(db);
+
+  app.get(
+    "/comments/read",
+    [
+      authJwt.verifyToken(true),
+      abac.middleware('comments', 'read', { 
+        allowPublished: true, 
+        allowUnauthenticated: true 
+      })
+    ],
+    controller.read
+  );
+
+  app.post(
+    "/comments/create",
+    [
+      authJwt.verifyToken(),
+      abac.middleware('comments', 'create'),
+    ],
+    controller.create
+  );
+
+  app.post(
+    "/comments/update/:url",
+    [
+      authJwt.verifyToken(),
+      abac.middleware('comments', 'edit'),
+    ],
+    controller.update
+  );
+
+  app.delete(
+    "/comments/delete/:url",
+    [
+      authJwt.verifyToken(),
+      abac.middleware('comments', 'delete'),
+    ],
+    controller.delete
+  );
+};
+

package/src/modules/community/routes/reactions.routes.js

@@ -0,0 +1,47 @@
+const controllerFactory = require("../controllers/reactions.controller");
+
+const middlewareFactoryAuth = require('@martyrs/src/modules/auth/controllers/middlewares');
+// ABAC
+const { getInstance } = require('@martyrs/src/modules/globals/controllers/classes/globals.abac.js')
+
+
+
+module.exports = function(app, db) {
+  const controller = controllerFactory(db);
+
+  const abac = getInstance(db);
+  const { authJwt } = middlewareFactoryAuth(db);
+
+  app.get(
+    "/api/reactions/read",
+    [
+      authJwt.verifyToken(true),
+    ],
+    controller.read
+  );
+
+  app.post(
+    "/api/reactions/create",
+    [
+      authJwt.verifyToken(),
+    ],
+    controller.create
+  );
+
+  app.post(
+    "/api/reactions/update",
+    [
+      authJwt.verifyToken(),
+    ],
+    controller.update
+  );
+
+  app.post(
+    "/api/reactions/delete",
+    [
+      authJwt.verifyToken(),
+    ],
+    controller.delete
+  );
+};
+

package/src/modules/community/store/blogposts.js

@@ -0,0 +1,196 @@
+// Vue modules
+import { reactive, ref, computed, toRefs, watch  } from "vue";
+// Axios
+import $axios from '@martyrs/src/modules/globals/views/utils/axios-instance.js';
+// Globals
+import { setError } from '@martyrs/src/modules/globals/views/store/globals'
+// State
+const state = reactive({
+  all: [],
+  filter: {
+    // query
+    tags: [],
+    period: '',
+    // pagination
+  },
+  pagination: {
+    page: 1,
+    perPage: 18,
+  },
+  // Sort
+  sort: {
+    param: 'createdAt',
+    order: 'desc',
+    hideButton: true,
+    options: [{
+      label: 'Date',
+      value: 'createdAt'
+    },{
+      label: 'Popularity',
+      value: 'views'
+    },{
+      label: 'Creator',
+      value: 'creator'
+    }]
+  },
+  current: null
+});
+
+async function read(options = {}) {
+  options.params = options.params || {};
+  options.params.skip = options.skip || 0;
+  options.params.limit = options.limit || 9;
+  options.params.tags = options.tags || [];
+  // Period
+  if (options.period) {
+    options.params.period = options.period;
+  }
+  // Handle fetching a specific post by _id
+  if (options.url) {
+    options.params = { url: options.url };
+  }
+  // Handle fetching posts by category
+  if (options.category) {
+    options.params.category = options.category;
+  }
+  // Owner
+  if (options.owner) {
+    options.params.owner = options.owner;
+  }
+  // Following
+   if (options.following) {
+    options.params.following = options.following;
+  }
+  // Creator
+   if (options.creator) {
+    options.params.creator = options.creator;
+  }
+    // Status
+  if (options.status) {
+    options.params.status = options.status;
+  }
+  // User
+  if (options.user) {
+    options.params.user = options.user;
+  }
+  // Sort
+  if (options.sortParam) {
+    options.params.sortParam = options.sortParam;
+  }
+  if (options.sortOrder) {
+    options.params.sortOrder = options.sortOrder;
+  }
+  // Handle pagination
+  options.params.skip = options.skip || 0;
+  options.params.limit = options.limit || 10;
+
+  try {
+    console.log('params is', options.params)
+    const response = await $axios.get('/api/blog/read', { params: options.params });
+    
+    if (options.url) {
+      if (response.data && response.data.length > 0) {
+        state.current = response.data[0];
+      } else {
+        state.current = null;
+      }
+    } else {
+      state.all = response.data;
+    }
+    
+    return Promise.resolve(response.data);
+  } catch (err) {
+    setError(err)
+     return Promise.reject(err);
+  }
+}
+async function create(blogpost) {
+  return $axios.post('/api/blog/create', blogpost).then(
+    response => {
+      set(response.data, 'current')
+      return Promise.resolve(response.data);
+    },
+    error => {
+      setError(error)
+      return Promise.reject(error);
+    }
+  );
+}
+
+async function update(blogpost) {
+  return $axios.post('/api/blog/update', blogpost).then(
+    response => {
+      set(response.data, 'current')
+      return Promise.resolve(response.data);
+    },
+    error => {
+      setError(error)
+      return Promise.reject(error);
+    }
+  );
+}
+
+async function remove(_id) {
+  return  await $axios.delete(`/api/blog/delete/${_id}`).then(
+    response => {
+      const index = state.all.findIndex(p => p._id === _id);
+          if (index !== -1) {
+            state.all.splice(index, 1);
+          }
+      return Promise.resolve(response.data);
+    },
+    error => {
+      setError(error)
+      return Promise.reject(error);
+    }
+  );
+}
+
+function set(blogpost,property) { 
+  state[property] = blogpost
+}
+
+function clean () {
+  state.current = {
+    _id: "",
+    url: "",
+    status: "",
+    name: "",
+    tags: [],
+    author: "",
+    owner: '',
+    date: "",
+    views: 0,
+    content: []
+  }
+}
+
+// Actions
+function blockAdd (block) {
+  const blockNew = {
+    order: state.project.content.length + 1,
+    type: block.type,
+    data: block.data,
+    class: block.class,
+    content: block.content
+  }
+  state.project.content.push(blockNew)
+}
+
+const history = []
+history.push(state) // push initial state
+
+watch(state, (newState, oldState) => {
+  history.push(newState)
+})
+
+export {
+  state,
+  read,
+  create,
+  update,
+  set,
+  clean,
+  remove,
+  blockAdd
+}

package/src/modules/community/store/reactions.js

@@ -0,0 +1,121 @@
+// Vue modules
+import { reactive, watch } from "vue";
+
+// Globals 
+import { setError } from '@martyrs/src/modules/globals/views/store/globals';
+
+// Setup Axios
+import $axios from '@martyrs/src/modules/globals/views/utils/axios-instance.js';
+
+// State
+const state = reactive({
+  reactions: [],
+  error: null,
+});
+
+// Methods
+const actions = {
+   async read(options) {
+    try {
+      // Initialize an empty params object
+      const params = {};
+
+      // Add properties to params if they exist in options
+      if (options.user) {
+        params.user = options.user;
+      }
+      if (options.type) {
+        params.type = options.type;
+      }
+      if (options.target) {
+        params.target = options.target;
+      }
+      if (options.targetString) {
+        params.targetString = options.targetString;
+      }
+
+      // Sending the request with the params object
+      const response = await $axios.get(`/api/reactions/read`, { params });
+      state.error = null;
+      state.reactions = response.data;
+      return Promise.resolve(response.data);
+    } catch (error) {
+      setError(error);
+      return Promise.reject(error);
+    }
+  },
+  async create(reaction) {
+    try {
+      const response = await $axios.post(`/api/reactions/create`, reaction);
+      state.error = null;
+      return Promise.resolve(response.data);
+    } catch (error) {
+      console.log(error)
+      setError(error);
+      return Promise.reject(error);
+    }
+  },
+  async update(reaction) {
+    try {
+      const response = await $axios.post(`/api/reactions/update`, reaction);
+      state.error = null;
+      return Promise.resolve(response.data);
+    } catch (error) {
+      setError(error);
+      return Promise.reject(error);
+    }
+  },
+  async delete(reaction) {
+    try {
+      const response = await $axios.post(`/api/reactions/delete`, reaction);
+      state.error = null;
+      return Promise.resolve(response.data);
+    } catch (error) {
+      setError(error);
+      return Promise.reject(error);
+    }
+  },
+};
+
+const mutations = {
+  handleReactionUpdate(data, reaction, hasReaction) {
+    let entity;
+
+    if (Array.isArray(data)) {
+      entity = data.find(o => o._id === reaction.target);
+    } else if (typeof data === 'object' && data._id === reaction.target) {
+      entity = data;
+    }
+
+    if (entity) {
+      entity.hasReaction = hasReaction;
+
+      if (hasReaction) {
+        entity.reactions.push(reaction);
+        entity.numberOfReactions += 1;
+      } else {
+        const index = entity.reactions.findIndex(t => t._id === reaction._id);
+        if (index !== -1) {
+          entity.reactions.splice(index, 1);
+          entity.numberOfReactions -= 1;
+        }
+      }
+    }
+  }
+}
+
+// History
+const history = [];
+history.push(state);
+
+// Watch
+watch(state, (newState) => {
+  history.push(newState);
+});
+
+// Module Export
+export {
+  state,
+  actions,
+  mutations
+};

package/src/modules/constructor/components/elements/Audio.vue

@@ -0,0 +1,70 @@
+<template>
+  <div 
+    class="mn-b-thin w-100 radius-medium"
+  >
+      
+    <div v-if="prop.content" class="flex-center flex">
+      <audio controls class="w-100 h-max-30r">
+        <source :src="prop.content" type="video/mp4">
+        Your browser does not support the video tag.
+      </audio>
+    </div>
+
+    <div
+      v-else
+    >
+      <Upload 
+        v-model:field="audioUrl"
+        @file-change="onComponentSave"
+        type="audio"   
+        :placeholder="'Upload video'" 
+        class="
+          w-100
+          br-solid
+          br-1px
+          br-black-transp-10
+          pd-medium
+          radius-small
+          mn-b-thin
+        "
+      />
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { ref } from 'vue';
+
+import Upload         from '@martyrs/src/components/Upload/Upload.vue'
+
+const audioUrl = ref(null);
+const fileInput = ref(null);
+
+const props = defineProps([
+  'label',
+  'value',
+  'prop'
+]);
+
+const emit = defineEmits(['input', 'updateBlock']);
+
+function updateBlock(updatedBlock) {
+  const index = post.value.content.findIndex(block => block === updatedBlock);
+  if (index !== -1) {
+    post.value.content.splice(index, 1, updatedBlock);
+  }
+}
+
+
+function onComponentSave(url) {
+  audioUrl.value = url
+
+  if (audioUrl.value ) {
+    emit('input', audioUrl.value);
+    emit('updateBlock', props.prop, { content: audioUrl.value });
+  } else {
+    alert('Invalid embed code or source not allowed.');
+  }
+}
+
+</script>

package/src/modules/constructor/components/elements/Bullets.vue

@@ -0,0 +1,72 @@
+<template>
+  <div>
+  {{prop[content]}}
+  <textarea 
+    v-model="prop[content]" 
+    :placeholder="placeholder ? placeholder : 'Enter text'"
+    @input="handleInput" 
+    @focus="emit('focus', textarea)"
+    ref="textarea" 
+    tabindex="-1"
+    class="text-area mn-b-small">    
+  </textarea>
+</div>
+</template>
+
+<script setup="props">
+  import { computed, ref, onMounted, watch, nextTick, onUpdated } from 'vue'
+
+  const props = defineProps(
+    ['obj','label','prop','value','content','textarea','placeholder','index','ref']
+  )
+
+  const data = ref(props)
+  const textarea = ref(null)
+  const emit = defineEmits(['deleteBlock', 'addBlock','focus'])
+
+  function handleInput(event) {
+    const bulletRegex = /^\s*[-*]\s+(.*)/;
+    let lines = event.target.value.split(/\n+/);
+
+    let bulletLines = lines.map(line => {
+      const match = bulletRegex.exec(line);
+      return match ? match[1] : null;
+    }).filter(line => line !== null);
+
+    if (bulletLines.length > 0) {
+      props.prop[props.content] = bulletLines;
+      resize();
+    } else if (event.target.value.trim() === "") {
+      props.prop[props.content] = [];
+      resize();
+    }
+  }
+
+  function focus() {
+     nextTick(() => { 
+        textarea.value.focus();
+      })
+  }
+
+  function resize() {
+    textarea.value.style.height = "1rem";
+    textarea.value.style.height = textarea.value.scrollHeight + "px";
+  }
+
+  onUpdated(() => {
+    resize()
+  });
+
+  onMounted(() => {
+    resize()
+  });
+
+  watch(() => props.prop[props.content], (newValue) => {
+    if (!newValue || newValue.length === 0) {
+      emit('deleteBlock', props.prop)
+    }
+  });
+</script>
+
+<style lang="scss">
+</style>