feat: initial commit - Band Management application

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/academy/course-details.get.js

@@ -0,0 +1,6 @@
+import { db } from '@/server/fake-db/apps/academy'
+
+export default defineEventHandler(() => {
+  // return course Details
+  return db.courseDetails
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/academy/courses.get.js

@@ -0,0 +1,53 @@
+import is from '@sindresorhus/is'
+import { destr } from 'destr'
+import { db } from '@/server/fake-db/apps/academy'
+import { paginateArray } from '@/server/utils/paginateArray'
+
+export default defineEventHandler(event => {
+  const { q, hideCompleted, page = 1, itemsPerPage = 10, sortBy, orderBy, label = 'All Courses' } = getQuery(event)
+
+  // console.log(sortBy, orderBy);
+  const searchQuery = is.string(q) ? q : undefined
+  const queryLowered = (searchQuery ?? '').toString().toLowerCase()
+  const parsedHideCompleted = destr(hideCompleted)
+  const hideCompletedLocal = is.boolean(parsedHideCompleted) ? parsedHideCompleted : false
+  const parsedSortBy = destr(sortBy)
+  const sortByLocal = is.string(parsedSortBy) ? parsedSortBy : ''
+  const parsedOrderBy = destr(orderBy)
+  const orderByLocal = is.string(parsedOrderBy) ? parsedOrderBy : ''
+  const parsedItemsPerPage = destr(itemsPerPage)
+  const parsedPage = destr(page)
+  const itemsPerPageLocal = is.number(parsedItemsPerPage) ? parsedItemsPerPage : 10
+  const pageLocal = is.number(parsedPage) ? parsedPage : 1
+  const parsedLabel = destr(label)
+  const labelLocal = is.string(parsedLabel) ? parsedLabel : 'All Courses'
+
+  const filteredCourses = db.courses.filter(course => {
+    return ((course.courseTitle.toLowerCase().includes(queryLowered)
+            || course.user.toLowerCase().includes(queryLowered))
+            && !((course.completedTasks === course.totalTasks) && hideCompletedLocal)
+            && (labelLocal !== 'All Courses' ? course.tags.toLocaleLowerCase() === labelLocal?.toLowerCase() : true))
+  })
+
+  if (sortByLocal) {
+    if (sortByLocal === 'courseName') {
+      filteredCourses.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.courseTitle.localeCompare(b.courseTitle)
+        else
+          return b.courseTitle.localeCompare(a.courseTitle)
+      })
+    }
+    if (sortByLocal === 'progress') {
+      filteredCourses.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return (a.completedTasks / a.totalTasks) - (b.completedTasks / b.totalTasks)
+        else
+          return (b.completedTasks / b.totalTasks) - (a.completedTasks / a.totalTasks)
+      })
+    }
+  }
+  setResponseStatus(event, 200)
+  
+  return { courses: paginateArray(filteredCourses, itemsPerPageLocal, pageLocal), total: filteredCourses.length }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/calendar/[id].delete.js

@@ -0,0 +1,15 @@
+import { db } from '@/server/fake-db/apps/calendar'
+
+export default defineEventHandler(event => {
+  const eventId = getIntId(event, 'event Id is required to delete a event')
+
+  // Find the index of the event in the database
+  const eventIndex = db.events.findIndex(e => Number(e.id) === eventId)
+
+
+  // Remove event from the database
+  db.events.splice(eventIndex, 1)
+  setResponseStatus(event, 204)
+  
+  return null
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/calendar/[id].put.js

@@ -0,0 +1,22 @@
+import { db } from '@/server/fake-db/apps/calendar'
+
+export default defineEventHandler(async event => {
+  const updatedEvent = await readBody(event)
+
+  updatedEvent.id = Number(updatedEvent.id)
+
+
+  // Find the index of the event in the database
+  const currentEvent = db.events.find(e => e.id === updatedEvent.id)
+
+  // update event
+  if (currentEvent) {
+    Object.assign(currentEvent, updatedEvent)
+    setResponseStatus(event, 200)
+    
+    return currentEvent
+  }
+  setResponseStatus(event, 400)
+  
+  return { message: 'Something went wrong' }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/calendar/index.get.js

@@ -0,0 +1,14 @@
+import is from '@sindresorhus/is'
+import { destr } from 'destr'
+import { db } from '@/server/fake-db/apps/calendar'
+
+export default defineEventHandler(event => {
+  const queries = getQuery(event)
+  const parsedCalendars = destr(queries.calendars)
+  const calendars = is.array(parsedCalendars) ? parsedCalendars : parsedCalendars !== undefined ? [parsedCalendars] : undefined
+  const events = db.events.filter(e => calendars?.includes(e.extendedProps.calendar))
+
+  setResponseStatus(event, 200)
+  
+  return events
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/calendar/index.post.js

@@ -0,0 +1,15 @@
+import { db } from '@/server/fake-db/apps/calendar'
+
+export default defineEventHandler(async event => {
+  const eventToAdd = await readBody(event)
+
+
+  // Add the data to the database once validated
+  db.events.push({
+    ...eventToAdd,
+    id: genId(db.events),
+  })
+  setResponseStatus(event, 201)
+  
+  return { body: eventToAdd }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/chat/chats-and-contacts.get.js

@@ -0,0 +1,24 @@
+import { db } from '@/server/fake-db/apps/chat'
+
+export default defineEventHandler(async event => {
+  const { q = '' } = getQuery(event)
+  const qLowered = q.toLowerCase()
+
+  const chatsContacts = db.chats
+    .map(chat => {
+      const contact = JSON.parse(JSON.stringify(db.contacts.find(c => c.id === chat.userId)))
+
+      contact.chat = { id: chat.id, unseenMsgs: chat.unseenMsgs, lastMessage: chat.messages.at(-1) }
+      
+      return contact
+    })
+    .reverse()
+
+  const profileUserData = db.profileUser
+  
+  return {
+    chatsContacts: chatsContacts.filter(c => c.fullName.toLowerCase().includes(qLowered)),
+    contacts: db.contacts.filter(c => c.fullName.toLowerCase().includes(qLowered)),
+    profileUser: profileUserData,
+  }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/chat/chats/[id].get.js

@@ -0,0 +1,13 @@
+import { db } from '@/server/fake-db/apps/chat'
+
+export default defineEventHandler(async event => {
+  const userId = getIntId(event, 'User id is required to get chat messages')
+  const chat = db.chats.find(c => c.userId === userId)
+  if (chat)
+    chat.unseenMsgs = 0
+  
+  return {
+    chat,
+    contact: db.contacts.find(c => c.id === userId),
+  }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/chat/chats/[id].post.js

@@ -0,0 +1,44 @@
+import { db } from '@/server/fake-db/apps/chat'
+
+export default defineEventHandler(async event => {
+  // Get user id from URL
+  const chatId = getIntId(event, 'Chat id is required to send message')
+
+  // Get message from post data
+  const { message, senderId } = await readBody(event)
+  let activeChat = db.chats.find(chat => chat.userId === chatId)
+
+  const newMessageData = {
+    message,
+    time: String(new Date()),
+    senderId,
+    feedback: {
+      isSent: true,
+      isDelivered: false,
+      isSeen: false,
+    },
+  }
+
+
+  // If there's new chat for user create one
+  let isNewChat = false
+  if (activeChat === undefined) {
+    isNewChat = true
+    db.chats.push({
+      id: db.chats.length + 1,
+      userId: chatId,
+      unseenMsgs: 0,
+      messages: [newMessageData],
+    })
+    activeChat = db.chats.at(-1)
+  }
+  else {
+    activeChat.messages.push(newMessageData)
+  }
+  const response = { msg: newMessageData }
+  if (isNewChat)
+    response.chat = activeChat
+  setResponseStatus(event, 201)
+  
+  return response
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/ecommerce/customers/[id].get.js

@@ -0,0 +1,17 @@
+import { db } from '@/server/fake-db/apps/ecommerce'
+
+export default defineEventHandler(event => {
+  const customerId = getIntId(event, 'Customer id is required to get customer details')
+  const id = Number(customerId)
+  const customerIndex = db.customerData.findIndex(e => e.customerId === id)
+  const customer = db.customerData[customerIndex]
+
+  Object.assign(customer, {
+    status: 'Active',
+    contact: '+1 (234) 567 890',
+  })
+  if (customer)
+    return customer
+  else
+    setResponseStatus(event, 404)
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/ecommerce/customers/index.get.js

@@ -0,0 +1,71 @@
+import is from '@sindresorhus/is'
+import { destr } from 'destr'
+import { db } from '@/server/fake-db/apps/ecommerce'
+import { paginateArray } from '@/server/utils/paginateArray'
+
+export default defineEventHandler(event => {
+  const { q = '', page = 1, itemsPerPage = 10, sortBy, orderBy } = getQuery(event)
+  const parsedSortBy = destr(sortBy)
+  const sortByLocal = is.string(parsedSortBy) ? parsedSortBy : ''
+  const parsedOrderBy = destr(orderBy)
+  const orderByLocal = is.string(parsedOrderBy) ? parsedOrderBy : ''
+  const parsedItemsPerPage = destr(itemsPerPage)
+  const parsedPage = destr(page)
+  const itemsPerPageLocal = is.number(parsedItemsPerPage) ? parsedItemsPerPage : 10
+  const pageLocal = is.number(parsedPage) ? parsedPage : 1
+  const searchQuery = is.string(q) ? q : undefined
+  const queryLowered = (searchQuery ?? '').toString().toLowerCase()
+
+  const filteredCustomers = db.customerData.filter(customer => {
+    return (customer.customer.toLowerCase().includes(queryLowered)
+            || customer.country.toLowerCase().includes(queryLowered)
+            || customer.email.toLowerCase().includes(queryLowered))
+  }).reverse()
+
+
+  // Sort Customers
+  if (sortByLocal) {
+    if (sortByLocal === 'customer') {
+      filteredCustomers.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.customer.localeCompare(b.customer)
+        
+        return b.customer.localeCompare(a.customer)
+      })
+    }
+    if (sortByLocal === 'country') {
+      filteredCustomers.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.country.localeCompare(b.country)
+        
+        return b.country.localeCompare(a.country)
+      })
+    }
+    if (sortByLocal === 'customerId') {
+      filteredCustomers.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.customerId - b.customerId
+        
+        return b.customerId - a.customerId
+      })
+    }
+    if (sortByLocal === 'orders') {
+      filteredCustomers.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.order - b.order
+        
+        return b.order - a.order
+      })
+    }
+    if (sortByLocal === 'totalSpent') {
+      filteredCustomers.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.totalSpent - b.totalSpent
+        
+        return b.totalSpent - a.totalSpent
+      })
+    }
+  }
+  
+  return { customers: paginateArray(filteredCustomers, itemsPerPageLocal, pageLocal), total: filteredCustomers.length }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/ecommerce/orders/[id].delete.js

@@ -0,0 +1,14 @@
+import { db } from '@/server/fake-db/apps/ecommerce'
+
+export default defineEventHandler(event => {
+  const orderId = getIntId(event, 'Order id is required to get order details')
+  const id = Number(orderId)
+  const orderIndex = db.orderData.findIndex(e => e.id === id)
+  if (orderIndex >= 0) {
+    db.orderData.splice(orderIndex, 1)
+    setResponseStatus(event, 204)
+    
+    return null
+  }
+  setResponseStatus(event, 204)
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/ecommerce/orders/[id].get.js

@@ -0,0 +1,16 @@
+import { db } from '@/server/fake-db/apps/ecommerce'
+
+export default defineEventHandler(event => {
+  const orderId = getIntId(event, 'Customer id is required to get customer details')
+  const id = Number(orderId)
+  try {
+    const order = db.orderData.find(e => e.order === id)
+    if (order)
+      setResponseStatus(event, 200)
+    
+    return order
+  }
+  catch (error) {
+    setResponseStatus(event, 404)
+  }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/ecommerce/orders/index.get.js

@@ -0,0 +1,69 @@
+import { db } from '@/server/fake-db/apps/ecommerce'
+import { paginateArray } from '@/server/utils/paginateArray'
+import is from '@sindresorhus/is'
+import { destr } from 'destr'
+
+export default defineEventHandler(event => {
+  const { q = '', sortBy, orderBy, page = 1, itemsPerPage = 10 } = getQuery(event)
+  const searchQuery = is.string(q) ? q : undefined
+  const queryLower = (searchQuery ?? '').toString().toLowerCase()
+  const parsedSortBy = destr(sortBy)
+  const sortByLocal = is.string(parsedSortBy) ? parsedSortBy : ''
+  const parsedOrderBy = destr(orderBy)
+  const orderByLocal = is.string(parsedOrderBy) ? parsedOrderBy : ''
+  const parsedItemsPerPage = destr(itemsPerPage)
+  const parsedPage = destr(page)
+  const itemsPerPageLocal = is.number(parsedItemsPerPage) ? parsedItemsPerPage : 10
+  const pageLocal = is.number(parsedPage) ? parsedPage : 1
+
+  const filterOrders = db.orderData.filter(order => {
+    return (order.customer.toLowerCase().includes(queryLower)
+            || order.email.toLowerCase().includes(queryLower)
+            || order.order.toString().includes(queryLower))
+  }).reverse()
+
+  if (sortByLocal) {
+    if (sortByLocal === 'order') {
+      filterOrders.sort((a, b) => {
+        if (orderByLocal === 'desc')
+          return b.order - a.order
+        else
+          return a.order - b.order
+      })
+    }
+    if (sortByLocal === 'customers') {
+      filterOrders.sort((a, b) => {
+        if (orderByLocal === 'desc')
+          return b.customer.localeCompare(a.customer)
+        else
+          return a.customer.localeCompare(b.customer)
+      })
+    }
+    if (sortByLocal === 'date') {
+      filterOrders.sort((a, b) => {
+        if (orderByLocal === 'desc')
+          return Number(new Date(b.date)) - Number(new Date(a.date))
+        else
+          return Number(new Date(a.date)) - Number(new Date(b.date))
+      })
+    }
+    if (sortByLocal === 'status') {
+      filterOrders.sort((a, b) => {
+        if (orderByLocal === 'desc')
+          return b.status.localeCompare(a.status)
+        else
+          return a.status.localeCompare(b.status)
+      })
+    }
+    if (sortByLocal === 'spent') {
+      filterOrders.sort((a, b) => {
+        if (orderByLocal === 'desc')
+          return Number(b.spent) - Number(a.spent)
+        else
+          return Number(a.spent) - Number(b.spent)
+      })
+    }
+  }
+  
+  return { orders: paginateArray(filterOrders, itemsPerPageLocal, pageLocal), total: filterOrders.length }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/ecommerce/products/[id].delete.js

@@ -0,0 +1,14 @@
+import { db } from '@/server/fake-db/apps/ecommerce'
+
+export default defineEventHandler(event => {
+  const productId = getIntId(event, 'Product id is required to delete product')
+  const id = Number(productId)
+  const productIndex = db.products.findIndex(e => e.id === id)
+  if (productIndex >= 0) {
+    db.products.splice(productIndex, 1)
+    setResponseStatus(event, 204)
+    
+    return null
+  }
+  setResponseStatus(event, 204)
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/ecommerce/products/index.get.js

@@ -0,0 +1,92 @@
+import is from '@sindresorhus/is'
+import { destr } from 'destr'
+import { db } from '@/server/fake-db/apps/ecommerce'
+import { paginateArray } from '@/server/utils/paginateArray'
+
+export default defineEventHandler(event => {
+  const { q = '', stock = null, category = null, status = null, sortBy, orderBy, itemsPerPage = 10, page = 1 } = getQuery(event)
+  const searchQuery = is.string(q) ? q : undefined
+  const queryLower = (searchQuery ?? '').toString().toLowerCase()
+  const parsedStock = destr(stock)
+  const stockLocal = is.boolean(parsedStock) ? parsedStock : undefined
+  const parsedSortBy = destr(sortBy)
+  const sortByLocal = is.string(parsedSortBy) ? parsedSortBy : ''
+  const parsedOrderBy = destr(orderBy)
+  const orderByLocal = is.string(parsedOrderBy) ? parsedOrderBy : ''
+  const parsedItemsPerPage = destr(itemsPerPage)
+  const parsedPage = destr(page)
+  const itemsPerPageLocal = is.number(parsedItemsPerPage) ? parsedItemsPerPage : 10
+  const pageLocal = is.number(parsedPage) ? parsedPage : 1
+
+  // Filtering Products
+  let filteredProducts = db.products.filter(product => ((product.productName.toLowerCase().includes(queryLower) || product.productBrand.toLowerCase().includes(queryLower))
+        && product.category === (category || product.category)
+        && (product.status === (status || product.status))
+        && (typeof stockLocal === 'undefined' ? true : (product.stock === stockLocal)))).reverse()
+
+  // Sort
+  if (sortByLocal) {
+    if (sortByLocal === 'product') {
+      filteredProducts = filteredProducts.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.productName.toLowerCase() > b.productName.toLowerCase() ? 1 : -1
+        else if (orderByLocal === 'desc')
+          return a.productName.toLowerCase() < b.productName.toLowerCase() ? 1 : -1
+        
+        return 0
+      })
+    }
+    if (sortByLocal === 'category') {
+      filteredProducts = filteredProducts.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.category > b.category ? 1 : -1
+        else if (orderByLocal === 'desc')
+          return a.category < b.category ? 1 : -1
+        
+        return 0
+      })
+    }
+    if (sortByLocal === 'status') {
+      filteredProducts = filteredProducts.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.status > b.status ? 1 : -1
+        else if (orderByLocal === 'desc')
+          return a.status < b.status ? 1 : -1
+        
+        return 0
+      })
+    }
+    if (sortByLocal === 'price') {
+      filteredProducts = filteredProducts.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return Number(a.price.slice(1)) > Number(b.price.slice(1)) ? 1 : -1
+        else if (orderByLocal === 'desc')
+          return Number(a.price.slice(1)) < Number(b.price.slice(1)) ? 1 : -1
+        
+        return 0
+      })
+    }
+    if (sortByLocal === 'qty') {
+      filteredProducts = filteredProducts.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.qty > b.qty ? 1 : -1
+        else if (orderByLocal === 'desc')
+          return a.qty < b.qty ? 1 : -1
+        
+        return 0
+      })
+    }
+    if (sortByLocal === 'sku') {
+      filteredProducts = filteredProducts.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.sku > b.sku ? 1 : -1
+        else if (orderByLocal === 'desc')
+          return a.sku < b.sku ? 1 : -1
+        
+        return 0
+      })
+    }
+  }
+  
+  return { products: paginateArray(filteredProducts, itemsPerPageLocal, pageLocal), total: filteredProducts.length }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/ecommerce/referrals/index.get.js

@@ -0,0 +1,51 @@
+import is from '@sindresorhus/is'
+import { destr } from 'destr'
+import { db } from '@/server/fake-db/apps/ecommerce'
+import { paginateArray } from '@/server/utils/paginateArray'
+
+export default defineEventHandler(event => {
+  const { sortBy, itemsPerPage = 10, page = 1, orderBy } = getQuery(event)
+  const parsedSortBy = destr(sortBy)
+  const sortByLocal = is.string(parsedSortBy) ? parsedSortBy : ''
+  const parsedOrderBy = destr(orderBy)
+  const orderByLocal = is.string(parsedOrderBy) ? parsedOrderBy : ''
+  const parsedItemsPerPage = destr(itemsPerPage)
+  const parsedPage = destr(page)
+  const itemsPerPageLocal = is.number(parsedItemsPerPage) ? parsedItemsPerPage : 10
+  const pageLocal = is.number(parsedPage) ? parsedPage : 1
+  const filteredReferrals = db.referrals
+  if (sortByLocal) {
+    if (sortByLocal === 'users') {
+      filteredReferrals.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.user.toLowerCase() > b.user.toLowerCase() ? 1 : -1
+        else if (orderByLocal === 'desc')
+          return a.user.toLowerCase() < b.user.toLowerCase() ? 1 : -1
+        
+        return 0
+      })
+    }
+    if (sortByLocal === 'referred-id') {
+      filteredReferrals.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.referredId - b.referredId
+        else if (orderByLocal === 'desc')
+          return b.referredId - a.referredId
+        
+        return 0
+      })
+    }
+    if (sortByLocal === 'earning') {
+      filteredReferrals.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return Number(a.earning.slice(1)) - Number(b.earning.slice(1))
+        else if (orderByLocal === 'desc')
+          return Number(b.earning.slice(1)) - Number(a.earning.slice(1))
+        
+        return 0
+      })
+    }
+  }
+  
+  return { referrals: paginateArray(filteredReferrals, itemsPerPageLocal, pageLocal), total: filteredReferrals.length }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/ecommerce/reviews/[id].delete.js

@@ -0,0 +1,14 @@
+import { db } from '@/server/fake-db/apps/ecommerce'
+
+export default defineEventHandler(event => {
+  const reviewId = getIntId(event, 'Review id is required to get review details')
+  const id = Number(reviewId)
+  const reviewIndex = db.reviews.findIndex(e => e.id === id)
+  if (reviewIndex >= 0) {
+    db.reviews.splice(reviewIndex, 1)
+    setResponseStatus(event, 204)
+    
+    return null
+  }
+  setResponseStatus(event, 204)
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/ecommerce/reviews/index.get.js

@@ -0,0 +1,79 @@
+import is from '@sindresorhus/is'
+import { destr } from 'destr'
+import { db } from '@/server/fake-db/apps/ecommerce'
+import { paginateArray } from '@/server/utils/paginateArray'
+
+export default defineEventHandler(event => {
+  const { q = '', sortBy, orderBy, itemsPerPage = 10, page = 1, status } = getQuery(event)
+  const parsedSortBy = destr(sortBy)
+  const sortByLocal = is.string(parsedSortBy) ? parsedSortBy : ''
+  const parsedStatus = destr(status)
+  const parsedOrderBy = destr(orderBy)
+  const orderByLocal = is.string(parsedOrderBy) ? parsedOrderBy : ''
+  const parsedItemsPerPage = destr(itemsPerPage)
+  const parsedPage = destr(page)
+  const itemsPerPageLocal = is.number(parsedItemsPerPage) ? parsedItemsPerPage : 10
+  const pageLocal = is.number(parsedPage) ? parsedPage : 1
+  const searchQuery = is.string(q) ? q : undefined
+  const queryLower = (searchQuery ?? '').toString().toLowerCase()
+
+
+  // Filtering Reviews
+  const filteredReviews = db.reviews.filter(review => {
+    const { product, reviewer, email } = review
+    
+    return (((product.toLowerCase().includes(queryLower)
+            || reviewer.toLowerCase().includes(queryLower)
+            || email.toLowerCase().includes(queryLower)
+            || review.head.toLowerCase().includes(queryLower)
+            || review.para.toLowerCase().includes(queryLower))
+            && (review.status === parsedStatus || status === 'All')))
+  })
+
+
+  // Sort
+  if (sortByLocal) {
+    if (sortByLocal === 'product') {
+      filteredReviews.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.product.toLowerCase() > b.product.toLowerCase() ? 1 : -1
+        else if (orderByLocal === 'desc')
+          return a.product.toLowerCase() < b.product.toLowerCase() ? 1 : -1
+        
+        return 0
+      })
+    }
+    if (sortByLocal === 'reviewer') {
+      filteredReviews.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.reviewer.toLowerCase() > b.reviewer.toLowerCase() ? 1 : -1
+        else if (orderByLocal === 'desc')
+          return a.reviewer.toLowerCase() < b.reviewer.toLowerCase() ? 1 : -1
+        
+        return 0
+      })
+    }
+    if (sortByLocal === 'date') {
+      filteredReviews.sort((a, b) => {
+        if (orderByLocal === 'desc')
+          return Number(new Date(b.date)) - Number(new Date(a.date))
+        else if (orderByLocal === 'asc')
+          return Number(new Date(a.date)) - Number(new Date(b.date))
+        
+        return 0
+      })
+    }
+  }
+  if (sortByLocal === 'status') {
+    filteredReviews.sort((a, b) => {
+      if (orderByLocal === 'asc')
+        return a.status.toLowerCase() > b.status.toLowerCase() ? 1 : -1
+      else if (orderByLocal === 'desc')
+        return a.status.toLowerCase() < b.status.toLowerCase() ? 1 : -1
+      else
+        return 0
+    })
+  }
+  
+  return { reviews: paginateArray(filteredReviews, itemsPerPageLocal, pageLocal), total: filteredReviews.length }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/email/index.get.js

@@ -0,0 +1,33 @@
+import { destr } from 'destr'
+import { db } from '@/server/fake-db/apps/email'
+
+export default defineEventHandler(event => {
+  const { q = '', filter = 'inbox', label } = destr(getQuery(event))
+  const queryLowered = q.toLowerCase()
+  function isInFolder(email) {
+    if (filter === 'trashed')
+      return email.isDeleted
+    if (filter === 'starred')
+      return email.isStarred && !email.isDeleted
+    
+    return email.folder === (filter || email.folder) && !email.isDeleted
+  }
+
+  const filteredData = db.emails.filter(email => (email.from.name.toLowerCase().includes(queryLowered) || email.subject.toLowerCase().includes(queryLowered))
+        && isInFolder(email)
+        && (label ? email.labels.includes(label) : true))
+
+
+  // ------------------------------------------------
+  // Email Meta
+  // ------------------------------------------------
+  const emailsMeta = {
+    inbox: db.emails.filter(email => !email.isDeleted && !email.isRead && email.folder === 'inbox').length,
+    draft: db.emails.filter(email => email.folder === 'draft').length,
+    spam: db.emails.filter(email => !email.isDeleted && !email.isRead && email.folder === 'spam').length,
+  }
+
+  setResponseStatus(event, 200)
+  
+  return { emails: filteredData, emailsMeta }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/email/index.post.js

@@ -0,0 +1,36 @@
+import { destr } from 'destr'
+import { db } from '@/server/fake-db/apps/email'
+
+export default defineEventHandler(async event => {
+  const { ids: emailIds, data: dataToUpdate, label } = await readBody(event)
+  const labelLocal = destr(label)
+  if (!labelLocal) {
+    const emailIdsLocal = destr(emailIds)
+    function updateMailData(email) {
+      Object.assign(email, dataToUpdate)
+    }
+    db.emails.forEach(email => {
+      if (emailIdsLocal.includes(email.id))
+        updateMailData(email)
+    })
+    setResponseStatus(event, 200)
+    
+    return null
+  }
+  else {
+    function updateMailLabels(email) {
+      const labelIndex = email.labels.indexOf(label)
+      if (labelIndex === -1)
+        email.labels.push(label)
+      else
+        email.labels.splice(labelIndex, 1)
+    }
+    db.emails.forEach(email => {
+      if (emailIds.includes(email.id))
+        updateMailLabels(email)
+    })
+    setResponseStatus(event, 200)
+    
+    return null
+  }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/invoice/[id].delete.js

@@ -0,0 +1,17 @@
+import { database } from '@/server/fake-db/apps/invoice'
+
+export default defineEventHandler(event => {
+  // Get event id from URL
+  const invoiceId = getIntId(event, 'User id is required to get user details')
+
+  // Convert Id to number
+  const id = Number(invoiceId)
+  const invoiceIndex = database.findIndex(e => e.id === id)
+  if (invoiceIndex >= 0) {
+    database.splice(invoiceIndex, 1)
+    setResponseStatus(event, 204)
+    
+    return null
+  }
+  setResponseStatus(event, 204)
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/invoice/[id].get.js

@@ -0,0 +1,27 @@
+import { database } from '@/server/fake-db/apps/invoice'
+
+export default defineEventHandler(event => {
+  // Get event id from URL
+  const invoiceId = getIntId(event, 'User id is required to get user details')
+
+  // Convert Id to number
+  const id = Number(invoiceId)
+  const invoice = database.find(e => e.id === id)
+  if (!invoice) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Invoice not found',
+    })
+  }
+  
+  return {
+    invoice,
+    paymentDetails: {
+      totalDue: '$12,110.55',
+      bankName: 'American Bank',
+      country: 'United States',
+      iban: 'ETD95476213874685',
+      swiftCode: 'BR91905',
+    },
+  }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/invoice/clients.get.js

@@ -0,0 +1,9 @@
+import { database } from '@/server/fake-db/apps/invoice'
+
+export default defineEventHandler(event => {
+  const clients = database.map(invoice => invoice.client)
+
+  setResponseStatus(event, 200)
+  
+  return clients.splice(0, 5)
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/invoice/index.get.js

@@ -0,0 +1,83 @@
+import { database } from '@/server/fake-db/apps/invoice'
+import is from '@sindresorhus/is'
+import { destr } from 'destr'
+
+export default defineEventHandler(event => {
+  const { q, status, selectedDateRange, sortBy = '', page = 1, itemsPerPage = 10, orderBy } = getQuery(event)
+  const searchQuery = is.string(q) ? q : undefined
+  const queryLowered = (searchQuery ?? '').toString().toLowerCase()
+  const parsedSortBy = destr(sortBy)
+  const sortByLocal = is.string(parsedSortBy) ? parsedSortBy : ''
+  const parsedOrderBy = destr(orderBy)
+  const orderByLocal = is.string(parsedOrderBy) ? parsedOrderBy : ''
+  const parsedItemsPerPage = destr(itemsPerPage)
+  const parsedPage = destr(page)
+  const itemsPerPageLocal = is.number(parsedItemsPerPage) ? parsedItemsPerPage : 10
+  const pageLocal = is.number(parsedPage) ? parsedPage : 1
+  const parsedDateRange = destr(selectedDateRange)
+  const startDateLocal = parsedDateRange?.start
+  const endDateLocal = parsedDateRange?.end
+
+  // Filtering invoices
+  let filteredInvoices = database.filter(invoice => ((invoice.client.name.toLowerCase().includes(queryLowered)
+        || invoice.client.companyEmail.toLowerCase().includes(queryLowered) || invoice.id.toString().includes(queryLowered))
+        && invoice.invoiceStatus === (status || invoice.invoiceStatus))).reverse()
+
+  // Sorting invoices
+  if (sortByLocal) {
+    if (sortByLocal === 'client') {
+      filteredInvoices = filteredInvoices.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.client.name.localeCompare(b.client.name)
+        
+        return b.client.name.localeCompare(a.client.name)
+      })
+    }
+    else if (sortByLocal === 'total') {
+      filteredInvoices = filteredInvoices.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.total - b.total
+        
+        return b.total - a.total
+      })
+    }
+    else if (sortByLocal === 'id') {
+      filteredInvoices = filteredInvoices.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.id - b.id
+        
+        return b.id - a.id
+      })
+    }
+    else if (sortByLocal === 'date') {
+      filteredInvoices = filteredInvoices.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return new Date(a.issuedDate).getTime() - new Date(b.issuedDate).getTime()
+        
+        return new Date(b.issuedDate).getTime() - new Date(a.issuedDate).getTime()
+      })
+    }
+    else if (sortByLocal === 'balance') {
+      filteredInvoices = filteredInvoices.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.balance - b.balance
+        
+        return b.balance - a.balance
+      })
+    }
+  }
+
+  // filtering invoices by date
+  if (startDateLocal && endDateLocal) {
+    filteredInvoices = filteredInvoices.filter(invoiceObj => {
+      const start = new Date(startDateLocal).getTime()
+      const end = new Date(endDateLocal).getTime()
+      const issuedDate = new Date(invoiceObj.issuedDate).getTime()
+      
+      return issuedDate >= start && issuedDate <= end
+    })
+  }
+  const totalInvoices = filteredInvoices.length
+  
+  return { invoices: paginateArray(filteredInvoices, itemsPerPageLocal, pageLocal), totalInvoices, page: pageLocal > Math.ceil(totalInvoices / itemsPerPageLocal) ? 1 : page }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/kanban/board/[id].delete.js

@@ -0,0 +1,14 @@
+import { database } from '@/server/fake-db/apps/kanban/index'
+
+export default defineEventHandler(async event => {
+  const boardId = getIntId(event, 'User id is required to get board details')
+  const boardIndex = database.boards.findIndex(board => board.id === boardId)
+  if (boardIndex === -1) {
+    setResponseStatus(event, 404)
+    
+    return { body: { message: `Board with id ${boardId} not found` } }
+  }
+  database.boards.splice(boardIndex, 1)
+  
+  return { body: { message: `Board with id ${boardId} deleted` } }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/kanban/board/add.post.js

@@ -0,0 +1,25 @@
+import { database } from '@/server/fake-db/apps/kanban/index'
+
+export default defineEventHandler(async event => {
+  const { title } = await readBody(event)
+
+  const getNewBoardId = () => {
+    const newBoardId = database.boards.length + 1
+    if (!(database.boards.some(board => board.id === newBoardId)))
+      return newBoardId
+    else
+      return newBoardId + 1
+  }
+
+  if (database.boards.some(board => board.title === title)) {
+    setResponseStatus(event, 204)
+  }
+  else {
+    database.boards.push({
+      id: getNewBoardId(),
+      title,
+      itemsIds: [],
+    })
+    setResponseStatus(event, 201)
+  }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/kanban/board/rename.put.js

@@ -0,0 +1,15 @@
+import { database } from '@/server/fake-db/apps/kanban/index'
+
+export default defineEventHandler(async event => {
+  const { boardId, newName } = await readBody(event)
+
+  database.boards = database.boards.map(board => {
+    if (board.id === boardId)
+      board.title = newName
+    
+    return board
+  })
+  setResponseStatus(event, 201)
+  
+  return { body: { message: `Rename Board with id ${newName}` } }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/kanban/board/state-update.put.js

@@ -0,0 +1,13 @@
+import { database } from '@/server/fake-db/apps/kanban'
+
+export default defineEventHandler(async event => {
+  const boardState = await readBody(event)
+
+
+  // sort board as per boardState
+  const sortedBoards = boardState.map(boardId => {
+    return database.boards.find(board => board.id === boardId)
+  })
+
+  database.boards = sortedBoards
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/kanban/index.get.js

@@ -0,0 +1,5 @@
+import { database } from '@/server/fake-db/apps/kanban/index'
+
+export default defineEventHandler(() => {
+  return database
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/kanban/item/[id].delete.js

@@ -0,0 +1,11 @@
+import { database } from '@/server/fake-db/apps/kanban'
+
+export default defineEventHandler(event => {
+  const itemId = getIntId(event, 'Item id is required to get item details')
+
+  database.items = database.items.filter(item => item.id !== itemId)
+  database.boards.forEach(board => {
+    board.itemsIds = board.itemsIds.filter(id => id !== itemId)
+  })
+  setResponseStatus(event, 204)
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/kanban/item/add.post.js

@@ -0,0 +1,28 @@
+import { database } from '@/server/fake-db/apps/kanban/'
+
+export default defineEventHandler(async event => {
+  const { boardId, boardName, itemTitle } = await readBody(event)
+  const itemId = database.items[database.items.length - 1].id + 1
+  if (itemTitle && boardName) {
+    // Add the new item to the items list
+    database.items.push({
+      id: itemId,
+      title: itemTitle,
+      attachments: 0,
+      comments: '',
+      commentsCount: 0,
+      dueDate: '',
+      labels: [],
+      members: [],
+    })
+
+
+    // find the index of board in the database
+    const id = database.boards.findIndex(board => board.id === boardId)
+
+
+    // Add the new item to the board
+    database.boards[id].itemsIds.push(itemId)
+  }
+  setResponseStatus(event, 201)
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/kanban/item/state-update.put.js

@@ -0,0 +1,11 @@
+import { database } from '@/server/fake-db/apps/kanban/'
+
+export default defineEventHandler(async event => {
+  const { boardId, ids } = await readBody(event)
+
+  database.boards.forEach(board => {
+    if (board.id === boardId)
+      board.itemsIds = ids
+  })
+  setResponseStatus(event, 201)
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/kanban/item/update.put.js

@@ -0,0 +1,18 @@
+import { database } from '@/server/fake-db/apps/kanban/'
+
+export default defineEventHandler(async event => {
+  const { item: task } = await readBody(event)
+
+  database.items.forEach(item => {
+    if (task && item.id === task.id) {
+      item.title = task.title
+      item.attachments = task.attachments
+      item.comments = task.comments
+      item.commentsCount = task.commentsCount
+      item.dueDate = task.dueDate
+      item.labels = task.labels
+      item.members = task.members
+    }
+  })
+  setResponseStatus(event, 201)
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/logistics/vehicles/index.js

@@ -0,0 +1,59 @@
+import is from '@sindresorhus/is'
+import { destr } from 'destr'
+import { db } from '@/server/fake-db/apps/logistics'
+
+export default defineEventHandler(event => {
+  const { sortBy, page = 1, itemsPerPage = 10, orderBy } = getQuery(event)
+  const parsedSortBy = destr(sortBy)
+  const sortByLocal = is.string(parsedSortBy) ? parsedSortBy : ''
+  const parsedOrderBy = destr(orderBy)
+  const orderByLocal = is.string(parsedOrderBy) ? parsedOrderBy : ''
+  const parsedItemsPerPage = destr(itemsPerPage)
+  const parsedPage = destr(page)
+  const itemsPerPageLocal = is.number(parsedItemsPerPage) ? parsedItemsPerPage : 10
+  const pageLocal = is.number(parsedPage) ? parsedPage : 1
+
+  // Sorting Vehicles
+  if (sortByLocal && sortByLocal === 'location') {
+    db.vehicles = db.vehicles.sort((a, b) => {
+      if (orderByLocal === 'asc')
+        return a.location - b.location
+      
+      return b.location - a.location
+    })
+  }
+  if (sortByLocal && sortByLocal === 'startRoute') {
+    db.vehicles = db.vehicles.sort((a, b) => {
+      if (orderByLocal === 'asc')
+        return a.startCity.localeCompare(b.startCity)
+      
+      return b.startCity.localeCompare(a.startCity)
+    })
+  }
+  if (sortByLocal && sortByLocal === 'endRoute') {
+    db.vehicles = db.vehicles.sort((a, b) => {
+      if (orderByLocal === 'asc')
+        return a.endCity.localeCompare(b.endCity)
+      
+      return b.endCity.localeCompare(a.endCity)
+    })
+  }
+  if (sortByLocal && sortByLocal === 'warnings') {
+    db.vehicles = db.vehicles.sort((a, b) => {
+      if (orderByLocal === 'asc')
+        return a.warnings.localeCompare(b.warnings)
+      
+      return b.warnings.localeCompare(a.warnings)
+    })
+  }
+  if (sortByLocal && sortByLocal === 'progress') {
+    db.vehicles = db.vehicles.sort((a, b) => {
+      if (orderByLocal === 'asc')
+        return a.progress - b.progress
+      
+      return b.progress - a.progress
+    })
+  }
+  
+  return { vehicles: paginateArray(db.vehicles, itemsPerPageLocal, pageLocal), totalVehicles: db.vehicles.length }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/permissions/index.get.js

@@ -0,0 +1,32 @@
+import is from '@sindresorhus/is'
+import { destr } from 'destr'
+import { db } from '@/server/fake-db/apps/permissions'
+
+export default defineCachedEventHandler(event => {
+  const { q = '', sortBy, page = 1, itemsPerPage = 10, orderBy } = getQuery(event)
+  const parsedSortBy = destr(sortBy)
+  const sortByLocal = is.string(parsedSortBy) ? parsedSortBy : ''
+  const parsedOrderBy = destr(orderBy)
+  const orderByLocal = is.string(parsedOrderBy) ? parsedOrderBy : ''
+  const parsedItemsPerPage = destr(itemsPerPage)
+  const parsedPage = destr(page)
+  const itemsPerPageLocal = is.number(parsedItemsPerPage) ? parsedItemsPerPage : 10
+  const pageLocal = is.number(parsedPage) ? parsedPage : 1
+  const searchQuery = is.string(q) ? q : undefined
+  const queryLower = (searchQuery ?? '').toString().toLowerCase()
+  let filteredPermissions = db.permissions.filter(permissions => permissions.name.toLowerCase().includes(queryLower)
+        || permissions.createdDate.toLowerCase().includes(queryLower)
+        || permissions.assignedTo.some(i => i.toLowerCase().startsWith(queryLower)))
+
+  // Sorting Permissions
+  if (sortByLocal && sortByLocal === 'name') {
+    filteredPermissions = filteredPermissions.sort((a, b) => {
+      if (orderByLocal === 'asc')
+        return a.name.localeCompare(b.name)
+      
+      return b.name.localeCompare(a.name)
+    })
+  }
+  
+  return { permissions: paginateArray(filteredPermissions, itemsPerPageLocal, pageLocal), totalPermissions: filteredPermissions.length }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/users/[id].delete.js

@@ -0,0 +1,15 @@
+import { db } from '@/server/fake-db/apps/users'
+
+export default defineEventHandler(event => {
+  const userId = getIntId(event, 'User id is required to delete a user')
+
+  // Find the index of the user in the database
+  const userIndex = db.users.findIndex(user => user.id === userId)
+
+
+  // Remove user from the database
+  db.users.splice(userIndex, 1)
+  setResponseStatus(event, 204)
+  
+  return null
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/users/[id].get.js

@@ -0,0 +1,20 @@
+import { db } from '@/server/fake-db/apps/users'
+
+export default defineEventHandler(event => {
+  const userId = getIntId(event, 'User id is required to get user details')
+  const user = db.users.find(u => u.id === userId)
+  if (!user) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'User not found',
+    })
+  }
+  
+  return {
+    ...user,
+    taskDone: 1230,
+    projectDone: 568,
+    taxId: 'Tax-8894',
+    language: 'English',
+  }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/users/index.get.js

@@ -0,0 +1,72 @@
+import is from '@sindresorhus/is'
+import { destr } from 'destr'
+import { db } from '@/server/fake-db/apps/users/index'
+
+export default defineEventHandler(async event => {
+  const { q = '', role = null, plan = null, status = null, sortBy, itemsPerPage = 10, page = 1, orderBy } = getQuery(event)
+  const searchQuery = is.string(q) ? q : undefined
+  const queryLower = (searchQuery ?? '').toString().toLowerCase()
+  const parsedSortBy = destr(sortBy)
+  const sortByLocal = is.string(parsedSortBy) ? parsedSortBy : ''
+  const parsedOrderBy = destr(orderBy)
+  const orderByLocal = is.string(parsedOrderBy) ? parsedOrderBy : ''
+  const parsedItemsPerPage = destr(itemsPerPage)
+  const parsedPage = destr(page)
+  const itemsPerPageLocal = is.number(parsedItemsPerPage) ? parsedItemsPerPage : 10
+  const pageLocal = is.number(parsedPage) ? parsedPage : 1
+
+  // filter users
+  let filteredUsers = db.users.filter(user => ((user.fullName.toLowerCase().includes(queryLower) || user.email.toLowerCase().includes(queryLower)) && user.role === (role || user.role) && user.currentPlan === (plan || user.currentPlan) && user.status === (status || user.status))).reverse()
+
+  // sort users
+  if (sortByLocal) {
+    if (sortByLocal === 'user') {
+      filteredUsers = filteredUsers.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.fullName.localeCompare(b.fullName)
+        else
+          return b.fullName.localeCompare(a.fullName)
+      })
+    }
+    if (sortByLocal === 'email') {
+      filteredUsers = filteredUsers.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.email.localeCompare(b.email)
+        else
+          return b.email.localeCompare(a.email)
+      })
+    }
+    if (sortByLocal === 'role') {
+      filteredUsers = filteredUsers.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.role.localeCompare(b.role)
+        else
+          return b.role.localeCompare(a.role)
+      })
+    }
+    if (sortByLocal === 'plan') {
+      filteredUsers = filteredUsers.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.currentPlan.localeCompare(b.currentPlan)
+        else
+          return b.currentPlan.localeCompare(a.currentPlan)
+      })
+    }
+    if (sortByLocal === 'status') {
+      filteredUsers = filteredUsers.sort((a, b) => {
+        if (orderByLocal === 'asc')
+          return a.status.localeCompare(b.status)
+        else
+          return b.status.localeCompare(a.status)
+      })
+    }
+  }
+  const totalUsers = filteredUsers.length
+
+  // total pages
+  const totalPages = Math.ceil(totalUsers / itemsPerPageLocal)
+
+  setResponseStatus(event, 200)
+  
+  return { users: paginateArray(filteredUsers, itemsPerPageLocal, pageLocal), totalPages, totalUsers, page: pageLocal > Math.ceil(totalUsers / itemsPerPageLocal) ? 1 : page }
+})

resources/vuexy-admin-v10.11.1/nuxt-version/javascript-version/full-version/server/api/apps/users/index.post.js

@@ -0,0 +1,15 @@
+import { db } from '@/server/fake-db/apps/users'
+
+export default defineEventHandler(async event => {
+  const user = await readBody(event)
+
+
+  // Add the data to the database once validated
+  db.users.push({
+    ...user,
+    id: db.users.length + 1,
+  })
+  setResponseStatus(event, 201)
+  
+  return { body: user }
+})