├── components
    ├── emailStats.vue
    ├── mods
    │   └── monaco.js
    ├── footer.vue
    ├── appbar.vue
    ├── emailBox.vue
    ├── fileCard.vue
    ├── embed.vue
    └── templateCard.vue
├── assets
    ├── logo.png
    ├── global.scss
    └── variables.scss
├── static
    └── favicon.ico
├── api
    ├── assets
    │   └── trackerImage.png
    ├── controllers
    │   ├── tracker.controller.js
    │   ├── handlebars.controller.js
    │   ├── puppeteer.controller.js
    │   ├── excel.controller.js
    │   ├── bucket.controller.js
    │   ├── fileHandler.controller.js
    │   ├── gmail.controller.js
    │   └── db.controller.js
    ├── models
    │   ├── user.model.js
    │   ├── files.model.js
    │   ├── template.model.js
    │   └── email.model.js
    ├── routes
    │   ├── tracker.routes.js
    │   ├── basic.routes.js
    │   ├── fileHandler.routes.js
    │   ├── template.routes.js
    │   └── emails.routes.js
    └── index.js
├── plugins
    ├── prisma-highlight.js
    └── editor.js
├── jsconfig.json
├── .editorconfig
├── middleware
    └── auth.js
├── .eslintrc.js
├── store
    ├── README.md
    ├── systemConfig.js
    └── auth.js
├── pages
    ├── templates
    │   ├── rules.vue
    │   ├── index.vue
    │   ├── upload.vue
    │   └── create
    │   │   ├── _id.vue
    │   │   └── index.vue
    ├── home.vue
    ├── emails
    │   ├── _id.vue
    │   ├── index.vue
    │   └── send
    │   │   └── _id.vue
    ├── assets
    │   ├── upload.vue
    │   └── index.vue
    └── index.vue
├── layouts
    ├── error.vue
    ├── default.vue
    └── dashboard.vue
├── content
    ├── hello.md
    └── rules.md
├── package.json
├── README.md
├── .gitignore
├── Instructions.md
└── nuxt.config.js


/components/emailStats.vue:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/components/mods/monaco.js:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/components/footer.vue:
--------------------------------------------------------------------------------
1 | <template>
2 |   <div></div>
3 | </template>
4 | 


--------------------------------------------------------------------------------
/assets/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iresharma/G-Notify/HEAD/assets/logo.png


--------------------------------------------------------------------------------
/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iresharma/G-Notify/HEAD/static/favicon.ico


--------------------------------------------------------------------------------
/api/assets/trackerImage.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iresharma/G-Notify/HEAD/api/assets/trackerImage.png


--------------------------------------------------------------------------------
/assets/global.scss:
--------------------------------------------------------------------------------
1 | * {
2 |   font-family: "Open Sans", sans-serif;
3 | }
4 | 
5 | .logo {
6 |   font-family: "Prata", serif;
7 | }
8 | 


--------------------------------------------------------------------------------
/plugins/prisma-highlight.js:
--------------------------------------------------------------------------------
1 | import Vue from 'vue'
2 | import VuePrism from 'vue-prism'
3 | import 'prismjs/themes/prism.css'
4 | 
5 | Vue.use(VuePrism)
6 | 


--------------------------------------------------------------------------------
/assets/variables.scss:
--------------------------------------------------------------------------------
1 | // Ref: https://github.com/nuxt-community/vuetify-module#customvariables
2 | //
3 | // The variables you want to modify
4 | // $font-size-root: 20px;
5 | 


--------------------------------------------------------------------------------
/jsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "baseUrl": ".",
 4 |     "paths": {
 5 |       "~/*": ["./*"],
 6 |       "@/*": ["./*"],
 7 |       "~~/*": ["./*"],
 8 |       "@@/*": ["./*"]
 9 |     }
10 |   },
11 |   "exclude": ["node_modules", ".nuxt", "dist"]
12 | }
13 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | # editorconfig.org
 2 | root = true
 3 | 
 4 | [*]
 5 | indent_style = space
 6 | indent_size = 2
 7 | end_of_line = lf
 8 | charset = utf-8
 9 | trim_trailing_whitespace = true
10 | insert_final_newline = true
11 | 
12 | [*.md]
13 | trim_trailing_whitespace = false
14 | 


--------------------------------------------------------------------------------
/plugins/editor.js:
--------------------------------------------------------------------------------
 1 | import Vue from 'vue'
 2 | import MonacoEditor from 'gg-vue-monaco-editor'
 3 | 
 4 | import VueApexCharts from 'vue-apexcharts'
 5 | Vue.use(VueApexCharts)
 6 | 
 7 | Vue.component('Apexchart', VueApexCharts)
 8 | 
 9 | Vue.component('MonacoEditor', MonacoEditor)
10 | 


--------------------------------------------------------------------------------
/middleware/auth.js:
--------------------------------------------------------------------------------
 1 | export default function ({ app }) {
 2 |   // If the user is not authenticated
 3 |   app.router.beforeResolve((to, from, next) => {
 4 |     if (app.store.getters['auth/isLogged']) {
 5 |       next()
 6 |     } else {
 7 |       next('/index')
 8 |     }
 9 |   })
10 | }
11 | 


--------------------------------------------------------------------------------
/api/controllers/tracker.controller.js:
--------------------------------------------------------------------------------
 1 | // Tracking functions
 2 | import { addEmailRead } from './db.controller'
 3 | 
 4 | const addReadEntry = (id, email) => {
 5 |   return new Promise((resolve, reject) => {
 6 |     try {
 7 |       addEmailRead(id, email)
 8 |     } catch (err) { return reject(err) }
 9 |     return resolve()
10 |   })
11 | }
12 | 
13 | module.exports = { addReadEntry }
14 | 


--------------------------------------------------------------------------------
/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   root: true,
 3 |   env: {
 4 |     browser: true,
 5 |     node: true
 6 |   },
 7 |   parserOptions: {
 8 |     parser: '@babel/eslint-parser',
 9 |     requireConfigFile: false
10 |   },
11 |   extends: [
12 |     '@nuxtjs',
13 |     'plugin:nuxt/recommended'
14 |   ],
15 |   plugins: [
16 |   ],
17 |   // add your custom rules here
18 |   rules: {}
19 | }
20 | 


--------------------------------------------------------------------------------
/api/models/user.model.js:
--------------------------------------------------------------------------------
 1 | const mongoose = require('mongoose')
 2 | const userSchema = new mongoose.Schema(
 3 |   {
 4 |     _id: mongoose.Schema.Types.ObjectId,
 5 |     token: Object,
 6 |     user: Object,
 7 |     emails: [{
 8 |       type: mongoose.Schema.Types.ObjectId, ref: 'emails'
 9 |     }]
10 |   },
11 |   { database: 'g-notify', collection: 'users' }
12 | )
13 | module.exports = mongoose.model('User', userSchema)
14 | 


--------------------------------------------------------------------------------
/api/models/files.model.js:
--------------------------------------------------------------------------------
 1 | const mongoose = require('mongoose')
 2 | const fileSchema = new mongoose.Schema(
 3 |   {
 4 |     _id: mongoose.Schema.Types.ObjectId,
 5 |     name: String,
 6 |     path: String,
 7 |     size: Number,
 8 |     mimeType: String,
 9 |     user: { type: mongoose.Schema.Types.ObjectId, ref: 'users' }
10 |   },
11 |   { database: 'g-notify', collection: 'files' }
12 | )
13 | module.exports = mongoose.model('Files', fileSchema)
14 | 


--------------------------------------------------------------------------------
/store/README.md:
--------------------------------------------------------------------------------
 1 | # STORE
 2 | 
 3 | **This directory is not required, you can delete it if you don't want to use it.**
 4 | 
 5 | This directory contains your Vuex Store files.
 6 | Vuex Store option is implemented in the Nuxt.js framework.
 7 | 
 8 | Creating a file in this directory automatically activates the option in the framework.
 9 | 
10 | More information about the usage of this directory in [the documentation](https://nuxtjs.org/guide/vuex-store).
11 | 


--------------------------------------------------------------------------------
/pages/templates/rules.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <article>
 3 |     <h1>{{ page.title }}</h1>
 4 |     <nuxt-content :document="page" />
 5 |   </article>
 6 | </template>
 7 | 
 8 | <script>
 9 | export default {
10 |   layout: 'dashboard',
11 |   async asyncData ({ $content }) {
12 |     const page = await $content('rules').fetch()
13 | 
14 |     return {
15 |       page
16 |     }
17 |   },
18 |   head: {
19 |     title: 'Templating rules'
20 |   }
21 | }
22 | </script>
23 | 


--------------------------------------------------------------------------------
/api/models/template.model.js:
--------------------------------------------------------------------------------
 1 | const mongoose = require('mongoose')
 2 | const templateSchema = new mongoose.Schema(
 3 |   {
 4 |     _id: mongoose.Schema.Types.ObjectId,
 5 |     user: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
 6 |     content: String,
 7 |     likes: Number,
 8 |     plainText: String,
 9 |     name: String,
10 |     public: Boolean
11 |   },
12 |   { database: 'g-notify', collection: 'templates' }
13 | )
14 | module.exports = mongoose.model('Template', templateSchema)
15 | 


--------------------------------------------------------------------------------
/api/models/email.model.js:
--------------------------------------------------------------------------------
 1 | const mongoose = require('mongoose')
 2 | const emailsSchema = new mongoose.Schema(
 3 |   {
 4 |     _id: mongoose.Schema.Types.ObjectId,
 5 |     template: {
 6 |       type: mongoose.Schema.Types.ObjectId,
 7 |       ref: 'Template'
 8 |     },
 9 |     user: Object,
10 |     recipients: [{
11 |       type: Object
12 |     }],
13 |     subject: String
14 |   },
15 |   { database: 'g-notify', collection: 'emails' }
16 | )
17 | module.exports = mongoose.model('Emails', emailsSchema)
18 | 


--------------------------------------------------------------------------------
/api/controllers/handlebars.controller.js:
--------------------------------------------------------------------------------
 1 | const HandleBars = require('handlebars')
 2 | 
 3 | HandleBars.registerHelper('loud', (string) => {
 4 |   return string.toUpperCase()
 5 | })
 6 | 
 7 | HandleBars.registerHelper('timeStampTime', (timeStamp) => {
 8 |   const date = new Date(timeStamp * 1000)
 9 |   return `${date.getHours()}:${date.getMinutes()}`
10 | })
11 | 
12 | HandleBars.registerHelper('timeStampDate', (timeStamp) => {
13 |   const date = new Date(timeStamp * 1000)
14 |   return `${date.getDate()}/${date.getMonth()}/${date.getFullYear()}`
15 | })
16 | 


--------------------------------------------------------------------------------
/store/systemConfig.js:
--------------------------------------------------------------------------------
 1 | export const state = () => ({
 2 |   snackbar: {
 3 |     show: false,
 4 |     type: '',
 5 |     text: ''
 6 |   },
 7 |   drawer: false // initialized as null because vuetify takes null to default it to closed on mobile and open on desktop
 8 | })
 9 | 
10 | export const getters = {
11 |   snackbar: state => state.snackbar,
12 |   drawer: state => state.drawer
13 | }
14 | 
15 | export const mutations = {
16 |   SNACKBAR: (state, payload) => (state.snackbar = payload),
17 |   TOGGLE_DRAWER: state => (state.drawer = !state.drawer)
18 | }
19 | 


--------------------------------------------------------------------------------
/api/controllers/puppeteer.controller.js:
--------------------------------------------------------------------------------
 1 | const puppeteer = require('puppeteer')
 2 | 
 3 | const templateScreenshot = async (templateHTML, quality) => {
 4 |   const browser = await puppeteer.launch()
 5 |   const page = await browser.newPage()
 6 |   await page.setContent(templateHTML)
 7 |   await page.waitForTimeout(1000)
 8 |   const body = await page.$('body')
 9 |   const screenshot = await body.screenshot({
10 |     type: 'jpeg',
11 |     quality: quality === 'low' ? 30 : 100,
12 |     fullPage: !(quality === 'low')
13 |   })
14 |   await page.close()
15 |   await browser.close()
16 | 
17 |   return screenshot
18 | }
19 | 
20 | module.exports = { templateScreenshot }
21 | 


--------------------------------------------------------------------------------
/pages/home.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div class="container">
 3 |     <v-card
 4 |       elevation="5"
 5 |       outlined
 6 |       style="width: 20vw; color: white"
 7 |     >
 8 |       <apexchart width="380" type="donut" :options="options" :series="series" />
 9 |     </v-card>
10 |   </div>
11 | </template>
12 | 
13 | <script>
14 | export default {
15 |   layout: 'dashboard',
16 |   async asyncData ({ $axios }) {
17 |     const emailCount = await $axios.get('/api/emails/stats/all')
18 |     return { series: [emailCount.data.totalCount[0].totalCount, emailCount.data.readCount[0].readCount] }
19 |   },
20 |   data () {
21 |     return {
22 |       options: {
23 |         labels: ['Emails Read', 'Email Unread']
24 |       }
25 |     }
26 |   },
27 |   head: {
28 |     title: 'Home'
29 |   }
30 | }
31 | </script>
32 | 


--------------------------------------------------------------------------------
/api/routes/tracker.routes.js:
--------------------------------------------------------------------------------
 1 | // Tracking routes
 2 | 
 3 | const router = require('express').Router()
 4 | const trackerHandler = require('../controllers/tracker.controller')
 5 | const fileHandler = require('../controllers/fileHandler.controller')
 6 | 
 7 | router.get('/:templateId/:email', async (req, res) => {
 8 |   const { templateId, email } = req.params
 9 |   if (!templateId) {
10 |     return res.status(400).send('Template id not found')
11 |   } if (!email) {
12 |     return res.status(400).send('Email not found')
13 |   }
14 |   try {
15 |     await trackerHandler.addReadEntry(templateId, email)
16 |     return res.status(200).sendFile(fileHandler.trackerFilePath())
17 |   } catch (err) {
18 |     console.log(err)
19 |     return res.status(500).send(err)
20 |   }
21 | })
22 | 
23 | module.exports = router
24 | 


--------------------------------------------------------------------------------
/layouts/error.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <v-app dark>
 3 |     <h1 v-if="error.statusCode === 404">
 4 |       {{ pageNotFound }}
 5 |     </h1>
 6 |     <h1 v-else>
 7 |       {{ otherError }}
 8 |     </h1>
 9 |     <NuxtLink to="/">
10 |       Home page
11 |     </NuxtLink>
12 |   </v-app>
13 | </template>
14 | 
15 | <script>
16 | export default {
17 |   layout: 'empty',
18 |   props: {
19 |     error: {
20 |       type: Object,
21 |       default: null
22 |     }
23 |   },
24 |   data () {
25 |     return {
26 |       pageNotFound: '404 Not Found',
27 |       otherError: 'An error occurred'
28 |     }
29 |   },
30 |   head () {
31 |     const title =
32 |       this.error.statusCode === 404 ? this.pageNotFound : this.otherError
33 |     return {
34 |       title
35 |     }
36 |   }
37 | }
38 | </script>
39 | 
40 | <style scoped>
41 | h1 {
42 |   font-size: 20px;
43 | }
44 | </style>
45 | 


--------------------------------------------------------------------------------
/store/auth.js:
--------------------------------------------------------------------------------
 1 | export const state = () => ({
 2 |   user: {
 3 |     name: null,
 4 |     photoUrl: null,
 5 |     _id: null
 6 |   }
 7 | })
 8 | 
 9 | //* Getters
10 | export const getters = {
11 |   isLogged: state => Boolean(state.user.email),
12 |   user: state => state.user
13 | }
14 | 
15 | //* mutations
16 | export const mutations = {
17 |   SET_USER (state, payload, field = null) {
18 |     if (field) {
19 |       state.user[field] = payload
20 |     } else {
21 |       state.user = payload.user
22 |       if (!payload.user.name) { state.user.name = payload.user.email.split('@')[0] }
23 |     }
24 |     localStorage.setItem('user', JSON.stringify(payload))
25 |   },
26 |   LOAD_USER (state) {
27 |     if (localStorage.getItem('user')) {
28 |       const user = JSON.parse(localStorage.getItem('user'))
29 |       state.user = { ...user.user, id: user._id }
30 |     }
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/layouts/default.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <v-app dark>
 3 |     <app-bar />
 4 |     <v-main>
 5 |       <Nuxt />
 6 |     </v-main>
 7 |     <CustFooter />
 8 |     <v-snackbar
 9 |       v-model="snackbar.show"
10 |       absolute
11 |       bottom
12 |       :color="snackbar.type"
13 |       left
14 |       text
15 |       style="z-index: 999999999"
16 |     >
17 |       {{ snackbar.text }}
18 |     </v-snackbar>
19 |   </v-app>
20 | </template>
21 | 
22 | <script>
23 | import CustFooter from '@/components/footer.vue'
24 | import AppBar from '@/components/appbar.vue'
25 | 
26 | export default {
27 |   components: {
28 |     CustFooter,
29 |     AppBar
30 |   },
31 |   computed: {
32 |     snackbar: {
33 |       get () {
34 |         return this.$store.getters['systemConfig/snackbar']
35 |       },
36 |       set (val) {
37 |         this.$store.commit('systemConfig/SNACKBAR', val)
38 |       }
39 |     }
40 |   }
41 | }
42 | </script>
43 | 


--------------------------------------------------------------------------------
/content/hello.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: Getting started
 3 | description: 'Empower your NuxtJS application with @nuxt/content module: write in a content/ directory and fetch your Markdown, JSON, YAML and CSV files through a MongoDB like API, acting as a Git-based Headless CMS.'
 4 | ---
 5 | 
 6 | Empower your NuxtJS application with `@nuxtjs/content` module: write in a `content/` directory and fetch your Markdown, JSON, YAML and CSV files through a MongoDB like API, acting as a **Git-based Headless CMS**.
 7 | 
 8 | ## Writing content
 9 | 
10 | Learn how to write your `content/`, supporting Markdown, YAML, CSV and JSON: https://content.nuxtjs.org/writing.
11 | 
12 | ## Fetching content
13 | 
14 | Learn how to fetch your content with `$content`: https://content.nuxtjs.org/fetching.
15 | 
16 | ## Displaying content
17 | 
18 | Learn how to display your Markdown content with the `<nuxt-content>` component directly in your template: https://content.nuxtjs.org/displaying.


--------------------------------------------------------------------------------
/pages/emails/_id.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div class="container">
 3 |     <h1>Subject: {{ email.subject }}</h1>
 4 |     <h4>id: {{ email._id }}</h4>
 5 |     <v-row>
 6 |       <v-col cols="6">
 7 |         <v-card elevation="2" style="margin: 1rem 0">
 8 |           <v-card-text>
 9 |             <h3>Plain Text</h3>
10 |             <p>{{ email.template.plainText }}</p>
11 |           </v-card-text>
12 |         </v-card>
13 |         <v-data-table
14 |           :headers="[{text: 'Email Id', value: 'email'}]"
15 |           :items="email.recipients"
16 |         />
17 |       </v-col>
18 |       <v-col cols="6" v-html="email.template.content" />
19 |     </v-row>
20 |   </div>
21 | </template>
22 | 
23 | <script>
24 | export default {
25 |   layout: 'dashboard',
26 |   async asyncData ({ $axios, route }) {
27 |     const response = await $axios.get(`/api/emails/${route.params.id}`)
28 |     return { email: response.data.email }
29 |   }
30 | }
31 | </script>
32 | 
33 | <style>
34 | 
35 | </style>
36 | 


--------------------------------------------------------------------------------
/api/controllers/excel.controller.js:
--------------------------------------------------------------------------------
 1 | const readXlsxFile = require('read-excel-file/node')
 2 | 
 3 | const excelToList = (path) => {
 4 |   const VALID_COLUMNS = ['email',
 5 |     'email address',
 6 |     'contact email',
 7 |     'personal email',
 8 |     'contact_email',
 9 |     'personal_email',
10 |     'email_address',
11 |     'mail',
12 |     'mail id',
13 |     'mail_address',
14 |     'mail address',
15 |     'mailing address',
16 |     'mailing_address'
17 |   ]
18 |   return new Promise((resolve, reject) => {
19 |     console.log(path)
20 |     readXlsxFile(path).then((rows) => {
21 |       rows[0].forEach((row, index) => {
22 |         if (row !== null && typeof row !== 'undefined') {
23 |           if (VALID_COLUMNS.includes(row.toLowerCase())) {
24 |             resolve(rows.map(row => row[index]))
25 |           }
26 |         }
27 |       })
28 |       reject(Error(`Invalid columns:\n one of the following should be available: ${VALID_COLUMNS.join(',')}`))
29 |     })
30 |   })
31 | }
32 | 
33 | module.exports = { excelToList }
34 | 


--------------------------------------------------------------------------------
/components/appbar.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <v-app-bar
 3 |     app
 4 |   >
 5 |     <v-app-bar-nav-icon v-if="side" @click="toggleDrawer" />
 6 |     <v-toolbar-title class="logo">
 7 |       G-Notify
 8 |     </v-toolbar-title>
 9 |     <v-spacer />
10 |     <v-btn icon>
11 |       <v-icon>mdi-github</v-icon>
12 |     </v-btn>
13 |     <v-chip
14 |       v-if="isLogged"
15 |       elevation="0"
16 |       color="blue"
17 |       outlined
18 |     >
19 |       <b>
20 |         {{ user.name }}
21 |       </b>
22 |     </v-chip>
23 |     <v-btn icon @click="$vuetify.theme.dark = !$vuetify.theme.dark">
24 |       <v-icon>mdi-theme-light-dark</v-icon>
25 |     </v-btn>
26 |   </v-app-bar>
27 | </template>
28 | 
29 | <script>
30 | export default {
31 |   props: {
32 |     side: {
33 |       type: Boolean,
34 |       required: false,
35 |       default: false
36 |     }
37 |   },
38 |   data () {
39 |     return {
40 |       drawer: true
41 |     }
42 |   },
43 |   methods: {
44 |     toggleDrawer () {
45 |       this.$store.commit('systemConfig/TOGGLE_DRAWER')
46 |     }
47 |   }
48 | }
49 | </script>
50 | 


--------------------------------------------------------------------------------
/api/index.js:
--------------------------------------------------------------------------------
 1 | const express = require('express')
 2 | const logger = require('morgan')
 3 | const mongoose = require('mongoose')
 4 | const cors = require('cors')
 5 | const basicRouter = require('./routes/basic.routes')
 6 | const templateRouter = require('./routes/template.routes')
 7 | const emailRouter = require('./routes/emails.routes')
 8 | const trackerRouter = require('./routes/tracker.routes')
 9 | const fileManagerRouter = require('./routes/fileHandler.routes')
10 | 
11 | const app = express()
12 | 
13 | app.use(cors())
14 | 
15 | app.use(logger('dev'))
16 | app.use(express.urlencoded({ extended: true }))
17 | app.use(express.json())
18 | 
19 | const dbURI = process.env.dbURI || ''
20 | 
21 | mongoose
22 |   .connect(dbURI, {
23 |     useNewUrlParser: true
24 |   })
25 |   .then(() => console.log('Database Connected'))
26 |   .catch(err => console.log(err))
27 | 
28 | mongoose.Promise = global.Promise
29 | 
30 | app.use('/', basicRouter)
31 | app.use('/templates', templateRouter)
32 | app.use('/emails', emailRouter)
33 | app.use('/tracking', trackerRouter)
34 | app.use('/files', fileManagerRouter)
35 | 
36 | export default {
37 |   path: '/api',
38 |   handler: app
39 | }
40 | 


--------------------------------------------------------------------------------
/api/controllers/bucket.controller.js:
--------------------------------------------------------------------------------
 1 | // GCP bucket handler functions for asset management
 2 | 
 3 | const { Storage } = require('@google-cloud/storage')
 4 | const storage = new Storage({ keyFilename: 'bucket_key.json' })
 5 | const bucket = storage.bucket(process.env.BUCKET_NAME)
 6 | 
 7 | const uploadFile = (filePath, userId) => {
 8 |   return new Promise((resolve, reject) => {
 9 |     const options = {
10 |       destination: `${userId}/${filePath.split('/').pop().replace(' ', '+')}`
11 |     }
12 |     bucket.upload(filePath, options).then(resolve).catch(reject)
13 |   })
14 | }
15 | 
16 | const getSignedURL = (path) => {
17 |   return new Promise((resolve, reject) => {
18 |     const file = bucket.file(path)
19 |     const config = {
20 |       action: 'read',
21 |       expires: (+new Date()) + 86400000
22 |     }
23 |     file.getSignedUrl(config).then(resolve).catch(reject)
24 |   })
25 | }
26 | 
27 | const getEmbedLink = (path, days) => {
28 |   return new Promise((resolve, reject) => {
29 |     const file = bucket.file(path)
30 |     const config = {
31 |       action: 'read',
32 |       expires: (+new Date()) + (86400000 * days)
33 |     }
34 |     file.getSignedUrl(config).then(resolve).catch(reject)
35 |   })
36 | }
37 | 
38 | module.exports = { uploadFile, getSignedURL, getEmbedLink }
39 | 


--------------------------------------------------------------------------------
/api/controllers/fileHandler.controller.js:
--------------------------------------------------------------------------------
 1 | const fs = require('fs')
 2 | const path = require('path')
 3 | const dir = path.join(path.resolve(path.dirname('')), 'api')
 4 | const excel = require('./excel.controller')
 5 | const bucketHandler = require('./bucket.controller')
 6 | 
 7 | const readTemplate = (file) => {
 8 |   return new Promise((resolve, reject) => {
 9 |     fs.readFile(`${dir}/upload/${file}`, 'utf8', (err, data) => {
10 |       if (err) {
11 |         reject(err)
12 |       }
13 |       fs.unlinkSync(`${dir}/upload/${file}`)
14 |       resolve(data)
15 |     })
16 |   })
17 | }
18 | 
19 | const readExcel = (file) => {
20 |   return new Promise((resolve, reject) => {
21 |     excel.excelToList(`${dir}/upload/${file}`).then((data) => {
22 |       fs.unlinkSync(`${dir}/upload/${file}`)
23 |       resolve(data)
24 |     }).catch((err) => {
25 |       fs.unlinkSync(`${dir}/upload/${file}`)
26 |       reject(err)
27 |     })
28 |   })
29 | }
30 | 
31 | const uploadFile = (filePath, userID) => {
32 |   return new Promise((resolve, reject) => {
33 |     bucketHandler.uploadFile(filePath, userID).then(resolve).catch(reject)
34 |   })
35 | }
36 | 
37 | const unlinkFile = (file) => {
38 |   fs.unlink(`${dir}/upload/${file}`, (_, __) => console.info)
39 | }
40 | 
41 | const trackerFilePath = () => {
42 |   return `${dir}/assets/trackerImage.png`
43 | }
44 | 
45 | module.exports = { readTemplate, readExcel, uploadFile, unlinkFile, trackerFilePath }
46 | 


--------------------------------------------------------------------------------
/pages/assets/upload.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div class="container">
 3 |     <v-file-input
 4 |       v-model="files"
 5 |       chips
 6 |       counter
 7 |       multiple
 8 |       show-size
 9 |       truncate-length="20"
10 |       accept="image/*"
11 |     />
12 |     <v-btn @click="upload">
13 |       upload
14 |     </v-btn>
15 |   </div>
16 | </template>
17 | 
18 | <script>
19 | import { mapGetters } from 'vuex'
20 | export default {
21 |   layout: 'dashboard',
22 |   data () {
23 |     return {
24 |       files: []
25 |     }
26 |   },
27 |   computed: {
28 |     ...mapGetters({
29 |       user: 'auth/user'
30 |     })
31 |   },
32 |   methods: {
33 |     upload () {
34 |       console.log(this.files)
35 |       const formData = new FormData()
36 |       this.files.forEach((file) => {
37 |         formData.append('files', file)
38 |       })
39 |       this.$axios
40 |         .post('/api/files/upload', formData, {
41 |           headers: {
42 |             'Content-Type': 'multipart/form-data'
43 |           },
44 |           params: {
45 |             user: this.user.id
46 |           }
47 |         })
48 |         .then((response) => {
49 |           console.log(response)
50 |         })
51 |         .catch((error) => {
52 |           this.$store.commit('systemConfig/SNACKBAR', {
53 |             show: true,
54 |             type: 'danger',
55 |             text: error.message
56 |           })
57 |         })
58 |     }
59 |   }
60 | }
61 | </script>
62 | 
63 | <style>
64 | 
65 | </style>
66 | 


--------------------------------------------------------------------------------
/api/routes/basic.routes.js:
--------------------------------------------------------------------------------
 1 | // Routes go here and
 2 | 
 3 | const router = require('express').Router()
 4 | const dbFunction = require('../controllers/db.controller')
 5 | const gmail = require('../controllers/gmail.controller')
 6 | 
 7 | router.get('/', (req, res) => {
 8 |   return res.send('Hello World')
 9 | })
10 | 
11 | router.get('/auth', async (req, res) => {
12 |   let link
13 |   try {
14 |     link = await gmail.getCredLink()
15 |   } catch (err) {
16 |     console.error(err)
17 |     return res.status(500).send(err)
18 |   }
19 |   return res.send(link)
20 | })
21 | 
22 | router.post('/auth', async (req, res) => {
23 |   const code = req.body.code
24 |   let token
25 |   try {
26 |     token = await gmail.getToken(code)
27 |   } catch (err) {
28 |     console.error(err)
29 |     return res.status(500).send(err)
30 |   }
31 |   try {
32 |     const userInfo = await gmail.loadUser(JSON.stringify(token))
33 |     // console.log(userInfo)
34 |     const userData = await dbFunction.getUserData(userInfo.data.emailAddress, JSON.stringify(token))
35 |     // console.log(userData)
36 |     if (userData) {
37 |       return res.status(200).send({ new: false, userData })
38 |     } else {
39 |       const user = await dbFunction.createUser({ email: userInfo.data.emailAddress }, token)
40 |       // console.log({ new: true, ...user })
41 |       return res.status(200).send({ new: true, userData: user })
42 |     }
43 |   } catch (err) {
44 |     console.error(err)
45 |     return res.status(500).send(err)
46 |   }
47 | })
48 | 
49 | module.exports = router
50 | 


--------------------------------------------------------------------------------
/pages/emails/index.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div class="container">
 3 |     <div v-if="emails === null" class="loader">
 4 |       <v-progress-circular
 5 |         indeterminate
 6 |         color="primary"
 7 |       />
 8 |     </div>
 9 |     <div v-else-if="emails.length === 0">
10 |       <h1>
11 |         No emails found
12 |       </h1>
13 |     </div>
14 |     <v-row v-else>
15 |       <v-col
16 |         v-for="email in emails"
17 |         :key="email.id"
18 |         cols="4"
19 |       >
20 |         <emailBox
21 |           :id="email._id"
22 |           :subject="email.subject"
23 |           :plain-text="email.template.plainText"
24 |           :template-name="email.template.name"
25 |           :template-id="email.template._id"
26 |           :count="email.recipients.length"
27 |           :user="email.template.user"
28 |         />
29 |       </v-col>
30 |     </v-row>
31 |   </div>
32 | </template>
33 | 
34 | <script>
35 | import emailBox from '@/components/emailBox.vue'
36 | 
37 | export default {
38 |   components: { emailBox },
39 |   layout: 'dashboard',
40 |   async asyncData ({ $axios, store }) {
41 |     const userEmail = store.getters['auth/user'].email
42 |     const response = await $axios.get(`/api/emails/list/${userEmail}`)
43 |     return { emails: response.data.emails }
44 |   },
45 |   data () {
46 |     return {
47 |       emails: null
48 |     }
49 |   }
50 | }
51 | </script>
52 | 
53 | <style>
54 | .loader {
55 |   width: 100%;
56 |   height: 90vh;
57 |   display: flex;
58 |   align-items: center;
59 |   justify-content: center;
60 | }
61 | </style>
62 | 


--------------------------------------------------------------------------------
/pages/assets/index.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div class="container">
 3 |     <div v-if="files === null" class="loader">
 4 |       <v-progress-circular
 5 |         indeterminate
 6 |         color="primary"
 7 |       />
 8 |     </div>
 9 |     <div v-else-if="files.length === 0">
10 |       <h1>
11 |         No files found
12 |       </h1>
13 |     </div>
14 |     <v-row v-else>
15 |       <v-col v-for="file in files" :key="file._id" cols="4">
16 |         <file-card :file="file" />
17 |       </v-col>
18 |     </v-row>
19 |     <v-tooltip top>
20 |       <template #activator="{ on, attrs }">
21 |         <v-btn
22 |           v-bind="attrs"
23 |           elevation="6"
24 |           fab
25 |           large
26 |           x-small
27 |           icon
28 |           style="position: fixed; bottom: 3rem; right: 3rem;"
29 |           v-on="on"
30 |           @click="$router.push('/assets/upload')"
31 |         >
32 |           <v-icon>mdi-file-upload-outline</v-icon>
33 |         </v-btn>
34 |       </template>
35 |       <span>Add files</span>
36 |     </v-tooltip>
37 |   </div>
38 | </template>
39 | 
40 | <script>
41 | import fileCard from '@/components/fileCard.vue'
42 | export default {
43 |   components: {
44 |     fileCard
45 |   },
46 |   layout: 'dashboard',
47 |   async asyncData ({ $axios, store }) {
48 |     const userId = store.getters['auth/user']._id
49 |     const response = await $axios.get('/api/files/list', {
50 |       params: {
51 |         user: userId
52 |       }
53 |     })
54 |     return { files: response.data }
55 |   }
56 | }
57 | </script>
58 | 
59 | <style>
60 | 
61 | </style>
62 | 


--------------------------------------------------------------------------------
/api/routes/fileHandler.routes.js:
--------------------------------------------------------------------------------
 1 | // file handler controller
 2 | 
 3 | const path = require('path')
 4 | const dir = path.join(path.resolve(path.dirname('')), 'api')
 5 | const router = require('express').Router()
 6 | const multer = require('multer')
 7 | const dbFunction = require('../controllers/db.controller')
 8 | const bucketHandler = require('../controllers/bucket.controller')
 9 | 
10 | const storage = multer.diskStorage({
11 |   destination: `${dir}/upload`,
12 |   // overwriting the filename with an inline function to replace spaces to '-', making it better for URLs
13 |   filename: (_, file, cb) => {
14 |     cb(null, file.originalname.replace(' ', '-'))
15 |   }
16 | })
17 | 
18 | const upload = multer({
19 |   storage
20 | })
21 | 
22 | router.get('/list', async (req, res) => {
23 |   const userId = req.query.user
24 |   const files = await dbFunction.getFileByUserId(userId)
25 |   return res.status(200).send(files)
26 | })
27 | 
28 | router.post('/upload', upload.any('files'), async (req, res) => {
29 |   const files = req.files
30 |   const resp = await dbFunction.addFiles(req.query.user, files)
31 |   return res.status(200).send(resp)
32 | })
33 | 
34 | router.get('/cdn', async (req, res) => {
35 |   const path = req.query.path
36 |   const resp = await bucketHandler.getSignedURL(path)
37 |   return res.status(200).send(resp)
38 | })
39 | 
40 | router.get('/get-embed-link', async (req, res) => {
41 |   const path = req.query.path
42 |   const days = req.query.days
43 |   const resp = await bucketHandler.getEmbedLink(path, days)
44 |   return res.status(200).send(resp)
45 | })
46 | 
47 | module.exports = router
48 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "G-Notify",
 3 |   "version": "1.0.0",
 4 |   "private": true,
 5 |   "scripts": {
 6 |     "dev": "nuxt",
 7 |     "build": "nuxt build",
 8 |     "start": "nuxt start",
 9 |     "generate": "nuxt generate",
10 |     "lint:js": "eslint --ext \".js,.vue\" --ignore-path .gitignore .",
11 |     "lint": "npm run lint:js"
12 |   },
13 |   "dependencies": {
14 |     "@google-cloud/storage": "^5.18.1",
15 |     "@nuxt/content": "^1.14.0",
16 |     "@nuxtjs/axios": "^5.13.6",
17 |     "@nuxtjs/pwa": "^3.3.5",
18 |     "apexcharts": "^3.40.0",
19 |     "core-js": "^3.15.1",
20 |     "cors": "^2.8.5",
21 |     "exceljs": "^4.3.0",
22 |     "express": "^4.17.1",
23 |     "express-fileupload": "^1.2.1",
24 |     "gg-vue-monaco-editor": "^1.0.1",
25 |     "googleapis": "^39.2.0",
26 |     "handlebars": "^4.7.7",
27 |     "mimetext": "^2.0.6",
28 |     "mongoose": "^6.0.5",
29 |     "morgan": "^1.10.0",
30 |     "multer": "^1.4.3",
31 |     "nuxt": "^2.15.7",
32 |     "nuxt-highlightjs": "^1.0.1",
33 |     "puppeteer": "^10.4.0",
34 |     "read-excel-file": "^5.2.25",
35 |     "uuid": "^8.3.2",
36 |     "vue-apexcharts": "^1.6.2",
37 |     "vue-highlightjs": "^1.3.3",
38 |     "vue-lottie": "^0.2.1",
39 |     "vuetify": "^2.5.5"
40 |   },
41 |   "devDependencies": {
42 |     "@babel/eslint-parser": "^7.14.7",
43 |     "@nuxtjs/eslint-config": "^6.0.1",
44 |     "@nuxtjs/eslint-module": "^3.0.2",
45 |     "@nuxtjs/vuetify": "^1.12.1",
46 |     "eslint": "^7.29.0",
47 |     "eslint-plugin-nuxt": "^2.0.0",
48 |     "eslint-plugin-vue": "^7.12.1",
49 |     "vue-prism": "^1.0.5",
50 |     "vue2-ace-editor": "0.0.15"
51 |   }
52 | }
53 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # G-notify
 2 | 
 3 | G-notify is a mass mailer written in nuxt snd express without  any third party libraries like (nodemailer).
 4 | We directly contact GAPIs to send the mail.
 5 | 
 6 | ### Deplyment Status
 7 | 
 8 | [landing](https://g-notify-landing.netlify.app) [![Netlify Status](https://api.netlify.com/api/v1/badges/6605941a-8232-4d5b-9869-8722f91ca31d/deploy-status)](https://app.netlify.com/sites/g-notify-landing/deploys)
 9 | 
10 | [G-notify](https://g-notify.netlify.app) [![Netlify Status](https://api.netlify.com/api/v1/badges/fff5718f-e1d1-49ca-94e1-f9bf0b2499b4/deploy-status)](https://app.netlify.com/sites/g-notify/deploys)
11 | 
12 | ** The above hosted version on netify is not supported anymore **
13 | 
14 | ## Features
15 | - [x] Template collection 
16 | - [x] create template -
17 | - [x] upload template 
18 | - [x] send single template 
19 | - [x] send multiple template 
20 | - [~] asset management for people to upload files for hosting, basically a cdn mainly for images but also supports other things (untested after new gcp configs)
21 | - [x] tracking
22 | - [ ] stats
23 | ## how to start using
24 | - create a .env file with the following variables
25 |   ```bash
26 |     GMAIL_CLIENT_ID="your client id"
27 |     GMAIL_CLIENT_SECRET="your client secret"
28 |     GMAIL_REDIRECT_URL="your redirect url"
29 |     dbURI="your mongodb url"
30 |     BASEURL="http://localhost:3000"
31 |     BUCKET_NAME="your gcp bucket name"
32 |     DOMAIN="your server domain/IP address"
33 |   ```
34 | 
35 |   **you'd also need a service account json named `bucket_key.json`  with suitable permissions and saved in the root folder of the project**


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Created by .ignore support plugin (hsz.mobi)
 2 | ### Node template
 3 | # Logs
 4 | /logs
 5 | *.log
 6 | npm-debug.log*
 7 | yarn-debug.log*
 8 | yarn-error.log*
 9 | 
10 | # Runtime data
11 | pids
12 | *.pid
13 | *.seed
14 | *.pid.lock
15 | 
16 | # Directory for instrumented libs generated by jscoverage/JSCover
17 | lib-cov
18 | 
19 | # Coverage directory used by tools like istanbul
20 | coverage
21 | 
22 | # nyc test coverage
23 | .nyc_output
24 | 
25 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
26 | .grunt
27 | 
28 | # Bower dependency directory (https://bower.io/)
29 | bower_components
30 | 
31 | # node-waf configuration
32 | .lock-wscript
33 | 
34 | # Compiled binary addons (https://nodejs.org/api/addons.html)
35 | build/Release
36 | 
37 | # Dependency directories
38 | node_modules/
39 | jspm_packages/
40 | 
41 | # TypeScript v1 declaration files
42 | typings/
43 | 
44 | # Optional npm cache directory
45 | .npm
46 | 
47 | # Optional eslint cache
48 | .eslintcache
49 | 
50 | # Optional REPL history
51 | .node_repl_history
52 | 
53 | # Output of 'npm pack'
54 | *.tgz
55 | 
56 | # Yarn Integrity file
57 | .yarn-integrity
58 | 
59 | # dotenv environment variables file
60 | .env
61 | 
62 | # parcel-bundler cache (https://parceljs.org/)
63 | .cache
64 | 
65 | # next.js build output
66 | .next
67 | 
68 | # nuxt.js build output
69 | .nuxt
70 | 
71 | # Nuxt generate
72 | dist
73 | 
74 | # vuepress build output
75 | .vuepress/dist
76 | 
77 | # Serverless directories
78 | .serverless
79 | 
80 | # IDE / Editor
81 | .idea
82 | 
83 | # Service worker
84 | sw.*
85 | 
86 | # macOS
87 | .DS_Store
88 | 
89 | # Vim swap files
90 | *.swp
91 | 
92 | # Uploads
93 | src/api/uploads/*
94 | 
95 | bucket_key.json
96 | creds.json


--------------------------------------------------------------------------------
/components/emailBox.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <v-card
  3 |     elevation="3"
  4 |     :loading="loading"
  5 |   >
  6 |     <v-img
  7 |       :src="`/api/templates/renderTemplate?quality=low&id=${templateId}`"
  8 |       height="250"
  9 |     />
 10 |     <v-card-title>{{ subject }}</v-card-title>
 11 |     <v-card-text>
 12 |       <b>Template Name:</b> {{ templateName }}<br>
 13 |       <b>Plain Text:</b> {{ plainText }}<br>
 14 |       <b>Sent to:</b> {{ count }} <br>
 15 |     </v-card-text>
 16 | 
 17 |     <v-card-actions>
 18 |       <v-btn
 19 |         color="success lighten-2"
 20 |         text
 21 |         @click="$router.push(`/emails/${id}`)"
 22 |       >
 23 |         More info
 24 |       </v-btn>
 25 |       <v-btn
 26 |         color="primary lighten-2"
 27 |         outlined
 28 |         @click="sendTest"
 29 |       >
 30 |         Send Test
 31 |       </v-btn>
 32 |     </v-card-actions>
 33 |   </v-card>
 34 | </template>
 35 | 
 36 | <script>
 37 | export default {
 38 |   props: {
 39 |     subject: {
 40 |       type: String,
 41 |       required: true
 42 |     },
 43 |     plainText: {
 44 |       type: String,
 45 |       required: true
 46 |     },
 47 |     templateName: {
 48 |       type: String,
 49 |       required: true
 50 |     },
 51 |     templateId: {
 52 |       type: String,
 53 |       required: true
 54 |     },
 55 |     count: {
 56 |       type: Number,
 57 |       required: true
 58 |     },
 59 |     id: {
 60 |       type: String,
 61 |       required: true
 62 |     }
 63 |   },
 64 |   data () {
 65 |     return {
 66 |       loading: false
 67 |     }
 68 |   },
 69 |   methods: {
 70 |     sendTest () {
 71 |       this.loading = true
 72 |       this.$axios
 73 |         .get('/api/emails/sendTest', {
 74 |           params: {
 75 |             template: this.templateId,
 76 |             user: this.user
 77 |           }
 78 |         })
 79 |         .then((response) => {
 80 |           this.$store.commit('systemConfig/SNACKBAR', {
 81 |             show: true,
 82 |             type: 'success',
 83 |             text: 'Email sent to your email id'
 84 |           })
 85 |           this.loading = false
 86 |         })
 87 |         .catch((error) => {
 88 |           this.$store.commit('systemConfig/SNACKBAR', {
 89 |             show: true,
 90 |             type: 'danger',
 91 |             text: error.message
 92 |           })
 93 |           this.loading = false
 94 |         })
 95 |     }
 96 |   }
 97 | }
 98 | </script>
 99 | 
100 | <style>
101 | 
102 | </style>
103 | 


--------------------------------------------------------------------------------
/api/routes/template.routes.js:
--------------------------------------------------------------------------------
 1 | // Template related routes go here
 2 | const path = require('path')
 3 | const dir = path.join(path.resolve(path.dirname('')), 'api')
 4 | const router = require('express').Router()
 5 | const multer = require('multer')
 6 | const dbFunction = require('../controllers/db.controller')
 7 | const puppeteerController = require('../controllers/puppeteer.controller')
 8 | const fileHandler = require('../controllers/fileHandler.controller')
 9 | 
10 | const storage = multer.diskStorage({
11 |   destination: `${dir}/upload`,
12 |   // overwriting the filename with an inline function to replace spaces to '-', making it better for URLs
13 |   filename: (_, file, cb) => {
14 |     cb(null, file.originalname.replace(' ', '-'))
15 |   }
16 | })
17 | 
18 | const upload = multer({
19 |   storage
20 | })
21 | 
22 | router.get('/', async (req, res) => {
23 |   const templates = await dbFunction.getTemplates(req.query.page)
24 |   return res.status(200).send({ templates })
25 | })
26 | 
27 | router.get('/count', async (_, res) => {
28 |   const count = await dbFunction.getTemplateCount()
29 |   return res.status(200).send({ count })
30 | })
31 | 
32 | router.get('/renderTemplate', async (req, res) => {
33 |   const template = await dbFunction.getTemplate(req.query.id)
34 |   const image = await puppeteerController.templateScreenshot(template.content, req.query.quality)
35 |   res.writeHead(200, {
36 |     'Content-Type': 'image/png',
37 |     'Content-Length': image.length
38 |   })
39 |   res.end(image)
40 | })
41 | 
42 | router.post('/readTemplate', upload.single('file'), async (req, res) => {
43 |   if (!req.file) {
44 |     return res.status(400).send({ error: 'No file was uploaded' })
45 |   }
46 |   try {
47 |     const template = await fileHandler.readTemplate(req.file.path.split('/').pop())
48 |     return res.status(200).send({ template })
49 |   } catch (err) {
50 |     console.error(err)
51 |     return res.status(500).send({ err })
52 |   }
53 | })
54 | 
55 | router.post('/createTemplate', async (req, res) => {
56 |   const data = req.body
57 |   try {
58 |     const template = await dbFunction.createTemplate(data)
59 |     return res.status(200).send({ template })
60 |   } catch (err) {
61 |     console.error(err)
62 |     return res.status(500).send({ err })
63 |   }
64 | })
65 | 
66 | router.get('/:id', async (req, res) => {
67 |   const template = await dbFunction.getTemplate(req.params.id)
68 |   return res.status(200).send({ template })
69 | })
70 | 
71 | router.get('/:id/like', async (req, res) => {
72 |   const likes = await dbFunction.addLike(req.params.id)
73 |   return res.status(200).send({ likes })
74 | })
75 | 
76 | module.exports = router
77 | 


--------------------------------------------------------------------------------
/layouts/dashboard.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <v-app dark>
  3 |     <app-bar :side="true" />
  4 |     <v-navigation-drawer
  5 |       :mini-variant.sync="drawer"
  6 |       app
  7 |       permanent
  8 |       class="black white--text"
  9 |     >
 10 |       <v-list dense>
 11 |         <v-list-item
 12 |           v-for="item in items"
 13 |           :key="item.title"
 14 |           class="white--text"
 15 |           link
 16 |           @click="$router.push(item.to)"
 17 |         >
 18 |           <v-list-item-icon>
 19 |             <v-icon color="white">
 20 |               {{ item.icon }}
 21 |             </v-icon>
 22 |           </v-list-item-icon>
 23 | 
 24 |           <v-list-item-content>
 25 |             <v-list-item-title class="white--text font-weight-medium">
 26 |               {{ item.title }}
 27 |             </v-list-item-title>
 28 |           </v-list-item-content>
 29 |         </v-list-item>
 30 |         <v-btn
 31 |           v-if="!drawer"
 32 |           style="position: absolute; bottom: 2rem; right: 1rem;"
 33 |           icon
 34 |           @click.stop="toggleDrawer"
 35 |         >
 36 |           <v-icon>mdi-chevron-left</v-icon>
 37 |         </v-btn>
 38 |       </v-list>
 39 |     </v-navigation-drawer>
 40 |     <v-main style="padding-left: 4rem; padding-bottom: 4rem;">
 41 |       <Nuxt />
 42 |     </v-main>
 43 |     <CustFooter />
 44 |     <v-snackbar
 45 |       v-model="snackbar.show"
 46 |       absolute
 47 |       bottom
 48 |       :color="snackbar.type"
 49 |       left
 50 |       text
 51 |       style="z-index: 999999999"
 52 |     >
 53 |       {{ snackbar.text }}
 54 |     </v-snackbar>
 55 |   </v-app>
 56 | </template>
 57 | 
 58 | <script>
 59 | import { mapGetters } from 'vuex'
 60 | import CustFooter from '@/components/footer.vue'
 61 | import AppBar from '@/components/appbar.vue'
 62 | 
 63 | export default {
 64 |   components: {
 65 |     CustFooter,
 66 |     AppBar
 67 |   },
 68 |   layout: 'dashboard',
 69 |   data () {
 70 |     return {
 71 |       items: [
 72 |         { title: 'Home', icon: 'mdi-home', to: '/home' },
 73 |         { title: 'Templates', icon: 'mdi-view-dashboard', to: '/templates' },
 74 |         { title: 'Templating Rules', icon: 'mdi-book-variant', to: '/templates/rules' },
 75 |         { title: 'Mail', icon: 'mdi-at', to: '/emails' },
 76 |         { title: 'Assets', icon: 'mdi-file', to: '/assets' }
 77 |       ]
 78 |     }
 79 |   },
 80 |   computed: {
 81 |     ...mapGetters({
 82 |       drawer: 'systemConfig/drawer'
 83 |     }),
 84 |     snackbar: {
 85 |       get () {
 86 |         return this.$store.getters['systemConfig/snackbar']
 87 |       },
 88 |       set (val) {
 89 |         this.$store.commit('systemConfig/SNACKBAR', val)
 90 |       }
 91 |     }
 92 |   },
 93 |   beforeMount () {
 94 |     this.$store.commit('auth/LOAD_USER')
 95 |   },
 96 |   methods: {
 97 |     toggleDrawer () {
 98 |       this.$store.commit('systemConfig/TOGGLE_DRAWER')
 99 |     }
100 |   }
101 | }
102 | </script>
103 | 


--------------------------------------------------------------------------------
/Instructions.md:
--------------------------------------------------------------------------------
 1 | # G-Notify
 2 | 
 3 | ## Build Setup
 4 | 
 5 | ```bash
 6 | # install dependencies
 7 | $ npm install
 8 | 
 9 | # serve with hot reload at localhost:3000
10 | $ npm run dev
11 | 
12 | # build for production and launch server
13 | $ npm run build
14 | $ npm run start
15 | 
16 | # generate static project
17 | $ npm run generate
18 | ```
19 | 
20 | For detailed explanation on how things work, check out the [documentation](https://nuxtjs.org).
21 | 
22 | ## Special Directories
23 | 
24 | You can create the following extra directories, some of which have special behaviors. Only `pages` is required; you can delete them if you don't want to use their functionality.
25 | 
26 | ### `assets`
27 | 
28 | The assets directory contains your uncompiled assets such as Stylus or Sass files, images, or fonts.
29 | 
30 | More information about the usage of this directory in [the documentation](https://nuxtjs.org/docs/2.x/directory-structure/assets).
31 | 
32 | ### `components`
33 | 
34 | The components directory contains your Vue.js components. Components make up the different parts of your page and can be reused and imported into your pages, layouts and even other components.
35 | 
36 | More information about the usage of this directory in [the documentation](https://nuxtjs.org/docs/2.x/directory-structure/components).
37 | 
38 | ### `layouts`
39 | 
40 | Layouts are a great help when you want to change the look and feel of your Nuxt app, whether you want to include a sidebar or have distinct layouts for mobile and desktop.
41 | 
42 | More information about the usage of this directory in [the documentation](https://nuxtjs.org/docs/2.x/directory-structure/layouts).
43 | 
44 | 
45 | ### `pages`
46 | 
47 | This directory contains your application views and routes. Nuxt will read all the `*.vue` files inside this directory and setup Vue Router automatically.
48 | 
49 | More information about the usage of this directory in [the documentation](https://nuxtjs.org/docs/2.x/get-started/routing).
50 | 
51 | ### `plugins`
52 | 
53 | The plugins directory contains JavaScript plugins that you want to run before instantiating the root Vue.js Application. This is the place to add Vue plugins and to inject functions or constants. Every time you need to use `Vue.use()`, you should create a file in `plugins/` and add its path to plugins in `nuxt.config.js`.
54 | 
55 | More information about the usage of this directory in [the documentation](https://nuxtjs.org/docs/2.x/directory-structure/plugins).
56 | 
57 | ### `static`
58 | 
59 | This directory contains your static files. Each file inside this directory is mapped to `/`.
60 | 
61 | Example: `/static/robots.txt` is mapped as `/robots.txt`.
62 | 
63 | More information about the usage of this directory in [the documentation](https://nuxtjs.org/docs/2.x/directory-structure/static).
64 | 
65 | ### `store`
66 | 
67 | This directory contains your Vuex store files. Creating a file in this directory automatically activates Vuex.
68 | 
69 | More information about the usage of this directory in [the documentation](https://nuxtjs.org/docs/2.x/directory-structure/store).
70 | 


--------------------------------------------------------------------------------
/content/rules.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: Templating Rules
 3 | description: HTML based email template rules.
 4 | ---
 5 | <br>
 6 | This reference assumes you’re a front-end web designer with an intermediate working knowledge of HTML and CSS. You’re comfortable coding in and using HTML tables for structure, and working in coding standards that were state-of-the-art in 1999. Feel free to crank up a little TLC or Goo Goo Dolls to get into the spirit of thing
 7 | 
 8 | <br>
 9 | <br>
10 | 
11 | <!--more-->
12 | 
13 | #### Best Practices: Design
14 | 
15 | There are a few things to keep in mind when designing HTML email campaigns.
16 | 
17 | <br>
18 | 
19 | - Emails should be 600-800 pixels maximum width. This will make them behave better within the preview-pane size provided by many clients.
20 | - Design for simplicity. Use grid-based layers and avoid complicated elements that require HTML floats or positioning.
21 | - Assume images will be initially blocked by email clients, or that certain images—background images, for example—will completely fail to load.
22 | - Don’t design an email that’s essentially one large, sliced-up image. While these kinds of emails look pretty, they perform poorly.
23 | - Use basic, cross-platform fonts such as Arial, Verdana, Georgia, and Times New Roman.
24 | - Avoid elements that require Flash or JavaScript. If you need motion in an email, a .gif is your best bet.
25 | - Don’t forget about the mobile experience! Is your email readable at arm’s length on a small screen? Will the images slow its load time on a mobile device? Are your links easy to press with a thumb?
26 | 
27 | <br>
28 | <br>
29 | 
30 | #### Best Practices: Development
31 | 
32 | Much like with design, there are best practices to follow when coding HTML email.
33 | 
34 | 
35 | - Code all structure using the table element. For more complicated layouts, you should nest tables to build complex structures.
36 | - Use element attributes (such as cellpadding, valign, and width) to set ta`ble dimensions. This forces a box-model structure.
37 | - Keep your CSS simple. Avoid compound style declarations (IE: “font:#000 12px Arial, Helvetica, sans-serif;”), shorthand code (IE: #000 instead of #000000), CSS layout properties (IE: slot, position, clear, visibility, etc.), complex selectors (IE: descendant, child or sibling selectors, and pseudo-elements)
38 | - Inline all CSS before sending. (Mailchimp will do this for you automatically.)
39 | - Use only absolute links for images, and host those images on a reliable server. (Mailchimp provides free image hosting.)
40 | - Don’t bother with JavaScript or Flash—those technologies are largely unsupported by email clients.
41 | - Account for mobile-friendliness, if possible. Use media queries to increase text sizes on small screens, provide thumb-sized (~46x46px) hit areas for links. Make an email responsive if the design allows for it.
42 | - Test, test, test. Create email accounts across various services, and send emails to yourself. Do this in conjunction with services such as [Litmus](https://www.litmus.com/).
43 | 
44 | [^1]: Sourece [MailChimp](https://templates.mailchimp.com/getting-started/html-email-basics/)
45 | 
46 | 


--------------------------------------------------------------------------------
/components/fileCard.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <v-card
  3 |     elevation="3"
  4 |   >
  5 |     <v-img
  6 |       :src="signedUrl"
  7 |       height="250"
  8 |     />
  9 |     <v-card-title style="display: flex; align-items: center; justify-content: space-between;">
 10 |       <div>
 11 |         {{ file.name }}
 12 |         <br>
 13 |         <small>id: {{ file._id }}</small>
 14 |       </div>
 15 |       <div>
 16 |         <v-btn
 17 |           icon
 18 |           color="success"
 19 |           @click="download"
 20 |         >
 21 |           <v-icon>mdi-download</v-icon>
 22 |         </v-btn>
 23 |       </div>
 24 |     </v-card-title>
 25 |     <v-card-text>
 26 |       <b>Type:</b> Image<br>
 27 |       <b>Path:</b> <code>{{ file.path }}</code><br>
 28 |       <b>Size:</b> {{ formatBytes(file.size) }} <br>
 29 |     </v-card-text>
 30 |     <v-card-actions>
 31 |       <v-btn-toggle>
 32 |         <v-btn @click="days--">
 33 |           <v-icon>mdi-minus</v-icon>
 34 |         </v-btn>
 35 | 
 36 |         <v-btn disabled>
 37 |           Days: {{ days }}
 38 |         </v-btn>
 39 | 
 40 |         <v-btn @click="days++">
 41 |           <v-icon>mdi-plus</v-icon>
 42 |         </v-btn>
 43 | 
 44 |         <v-btn :color="buttonColor" @click="getEmbedLink">
 45 |           {{ buttonMessage }}
 46 |         </v-btn>
 47 |       </v-btn-toggle>
 48 |     </v-card-actions>
 49 |   </v-card>
 50 | </template>
 51 | 
 52 | <script>
 53 | export default {
 54 |   props: {
 55 |     file: {
 56 |       type: Object,
 57 |       required: true
 58 |     }
 59 |   },
 60 |   data () {
 61 |     return {
 62 |       signedUrl: null,
 63 |       days: 1,
 64 |       embedURL: null,
 65 |       buttonColor: 'default',
 66 |       buttonMessage: 'Get embed link'
 67 |     }
 68 |   },
 69 |   async fetch () {
 70 |     const response = await this.$axios.get('/api/files/cdn', {
 71 |       params: {
 72 |         path: this.file.path
 73 |       }
 74 |     })
 75 |     this.signedUrl = response.data[0]
 76 |   },
 77 |   methods: {
 78 |     formatBytes (bytes, decimals = 2) {
 79 |       if (bytes === 0) { return '0 Bytes' }
 80 | 
 81 |       const k = 1024
 82 |       const dm = decimals < 0 ? 0 : decimals
 83 |       const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
 84 | 
 85 |       const i = Math.floor(Math.log(bytes) / Math.log(k))
 86 | 
 87 |       return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i]
 88 |     },
 89 |     download () {
 90 |       window.open(this.signedUrl, '_blank')
 91 |     },
 92 |     getEmbedLink () {
 93 |       this.$axios.get('/api/files/get-embed-link', {
 94 |         params: {
 95 |           path: this.file.path,
 96 |           days: this.days
 97 |         }
 98 |       }).then((response) => {
 99 |         this.embedURL = response.data[0]
100 |         if (navigator && navigator.clipboard && navigator.clipboard.writeText) {
101 |           this.buttonMessage = 'Link Copied'
102 |           this.buttonColor = 'success'
103 |           setTimeout(() => {
104 |             this.buttonMessage = 'Get embed link'
105 |             this.buttonColor = 'default'
106 |           }, 2000)
107 |           return navigator.clipboard.writeText(this.embedURL)
108 |         }
109 |         return Promise.reject(new Error('The Clipboard API is not available.'))
110 |       })
111 |     }
112 |   }
113 | }
114 | </script>
115 | 


--------------------------------------------------------------------------------
/pages/templates/index.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <div class="container">
  3 |     <v-alert
  4 |       color="red"
  5 |       dense
  6 |       icon="mdi-alert-circle-outline"
  7 |       text
  8 |       type="error"
  9 |     >
 10 |       The thumbnails are rendered using a headless browser hence looks slighlty different from the real website.
 11 |     </v-alert>
 12 |     <div class="grid">
 13 |       <templateCard
 14 |         v-for="template in templates"
 15 |         :id="template._id"
 16 |         :key="template._id"
 17 |         :desc="template.desc ? template.desc : 'No Description available'"
 18 |         :template-user="template.user"
 19 |         :template-content="template.content"
 20 |         :likes="template.likes"
 21 |         :name="template.name"
 22 |         @updateLikes="(e) => template.likes = e"
 23 |       />
 24 |     </div>
 25 |     <v-tooltip top>
 26 |       <template #activator="{ on, attrs }">
 27 |         <v-btn
 28 |           v-bind="attrs"
 29 |           elevation="6"
 30 |           fab
 31 |           large
 32 |           x-small
 33 |           icon
 34 |           style="position: fixed; bottom: 3rem; right: 2rem;"
 35 |           v-on="on"
 36 |           @click="$router.push('/templates/upload')"
 37 |         >
 38 |           <v-icon>mdi-file-upload-outline</v-icon>
 39 |         </v-btn>
 40 |       </template>
 41 |       <span>Upload template</span>
 42 |     </v-tooltip>
 43 |     <v-tooltip top>
 44 |       <template #activator="{ on, attrs }">
 45 |         <v-btn
 46 |           v-bind="attrs"
 47 |           elevation="6"
 48 |           fab
 49 |           large
 50 |           x-small
 51 |           icon
 52 |           style="position: fixed; bottom: 3rem; right: 7rem;"
 53 |           v-on="on"
 54 |           @click="$router.push('/templates/create')"
 55 |         >
 56 |           <v-icon>mdi-typewriter</v-icon>
 57 |         </v-btn>
 58 |       </template>
 59 |       <span>Create template</span>
 60 |     </v-tooltip>
 61 |     <v-pagination
 62 |       v-model="page"
 63 |       :length="length"
 64 |     />
 65 |   </div>
 66 | </template>
 67 | <script>
 68 | import templateCard from '@/components/templateCard.vue'
 69 | export default {
 70 |   components: {
 71 |     templateCard
 72 |   },
 73 |   layout: 'dashboard',
 74 |   async asyncData ({ $axios }) {
 75 |     const templates = await $axios.get('/api/templates', {
 76 |       params: {
 77 |         page: 0
 78 |       }
 79 |     })
 80 |     const length = await $axios.get('/api/templates/count')
 81 |     return { templates: templates.data.templates, length: Number((length.data.count / 20) + 1) }
 82 |   },
 83 |   data () {
 84 |     return {
 85 |       page: 1,
 86 |       templates: []
 87 |     }
 88 |   },
 89 |   head: {
 90 |     title: 'Templates'
 91 |   },
 92 |   watch: {
 93 |     page () {
 94 |       this.$axios.get('/api/templates', {
 95 |         params: {
 96 |           page: this.page - 1
 97 |         }
 98 |       }).then((response) => {
 99 |         this.templates = response.data.templates
100 |       }).catch((error) => {
101 |         this.$store.commit('systemConfig/SNACKBAR', {
102 |           show: true,
103 |           type: 'danger',
104 |           text: error.message
105 |         })
106 |       })
107 |     }
108 |   }
109 | }
110 | </script>
111 | 
112 | <style>
113 | .grid {
114 |   display: grid;
115 |   grid-template-columns: 1fr 1fr 1fr;
116 | }
117 | </style>
118 | 


--------------------------------------------------------------------------------
/pages/index.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <div class="container">
  3 |     <h1>
  4 |       G-Notify
  5 |     </h1>
  6 |     <p>
  7 |       A simple gmail backed HTML mass mailer with a jam pack of features
  8 |     </p>
  9 |     <p v-if="isLogged">
 10 |       <v-btn outlined rounded color="primary" @click="$router.push('/home')">
 11 |         Dashboard
 12 |       </v-btn>
 13 |       <v-btn elevation="0" color="accent" plain href="https://github.com/iresharma/G-Notify">
 14 |         <v-icon dense color="accent darken-2" class="mx-2">
 15 |           mdi-github
 16 |         </v-icon>
 17 |         Contribute
 18 |       </v-btn>
 19 |     </p>
 20 |     <p v-else>
 21 |       <v-btn
 22 |         outlined
 23 |         rounded
 24 |         :loading="loading"
 25 |         elevation="3"
 26 |         color="primary"
 27 |         @click="authorize"
 28 |       >
 29 |         Get Started
 30 |       </v-btn>
 31 |       <v-btn elevation="0" color="accent" plain>
 32 |         Learn More
 33 |       </v-btn>
 34 |     </p>
 35 |   </div>
 36 | </template>
 37 | 
 38 | <script>
 39 | import { mapGetters } from 'vuex'
 40 | 
 41 | export default {
 42 |   data () {
 43 |     return {
 44 |       loading: true
 45 |     }
 46 |   },
 47 |   head () {
 48 |     return {
 49 |       title: 'Home'
 50 |     }
 51 |   },
 52 |   computed: {
 53 |     ...mapGetters({ isLogged: 'auth/isLogged' })
 54 |   },
 55 |   mounted () {
 56 |     this.$store.commit('auth/LOAD_USER')
 57 |     this.loading = false
 58 |     if (this.$route.query.code) {
 59 |       this.sendCode(this.$route.query.code)
 60 |     }
 61 |   },
 62 |   methods: {
 63 |     authorize () {
 64 |       this.$axios
 65 |         .get('/api/auth', {
 66 |           params: {},
 67 |           headers: {
 68 |             'Content-Type': 'application/json'
 69 |           }
 70 |         })
 71 |         .then((response) => {
 72 |           this.dialog = true
 73 |           window.open(response.data, 'self')
 74 |         })
 75 |         .catch((error) => {
 76 |           this.$store.commit('systemConfig/SNACKBAR', {
 77 |             show: true,
 78 |             type: 'danger',
 79 |             text: error.message
 80 |           })
 81 |         })
 82 |     },
 83 |     sendCode (userCode) {
 84 |       this.$axios
 85 |         .post(
 86 |           '/api/auth',
 87 |           {
 88 |             code: userCode
 89 |           },
 90 |           {
 91 |             params: {},
 92 |             headers: {
 93 |               'Content-Type': 'application/json'
 94 |             }
 95 |           }
 96 |         )
 97 |         .then((response) => {
 98 |           this.dialog = false
 99 |           // console.log(response)
100 |           this.$store.commit('auth/SET_USER', { ...response.data.userData })
101 |           this.$router.push('/home')
102 |         })
103 |         .catch(error => this.$store.commit('systemConfig/SNACKBAR', {
104 |           show: true,
105 |           type: 'danger',
106 |           text: error.message
107 |         }))
108 |     }
109 |   }
110 | }
111 | </script>
112 | 
113 | <style lang="scss" scoped>
114 | .container {
115 |   display: flex;
116 |   flex-direction: column;
117 |   align-items: center;
118 |   justify-content: center;
119 |   height: 90vh;
120 |   width: 100%;
121 | 
122 |   h1 {
123 |     text-align: center;
124 |     color: white;
125 |     font-size: 100px;
126 |     text-shadow: 5px 5px 1px #118ab2;
127 |     transition: text-shadow 0.25s linear;
128 |   }
129 |   h1:hover {
130 |     text-shadow: -5px -5px 1px #e63946;
131 |   }
132 | 
133 |   p {
134 |     font-size: 1rem;
135 |     font-weight: normal;
136 |   }
137 | }
138 | </style>
139 | 


--------------------------------------------------------------------------------
/pages/templates/upload.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <div class="container">
  3 |     <div>
  4 |       <v-alert dense icon="mdi-information" text type="info" color="blue">
  5 |         While creating the template preferably put all your CSS in a style
  6 |         inside the body or make it inline.
  7 |       </v-alert>
  8 |       <v-alert
  9 |         dense
 10 |         icon="mdi-alert-circle-outline"
 11 |         text
 12 |         type="error"
 13 |         color="red"
 14 |       >
 15 |         The rendered version below isn't an accurate representation of what the
 16 |         email will look like.
 17 |       </v-alert>
 18 |       <v-row>
 19 |         <v-col>
 20 |           <v-file-input
 21 |             v-model="file"
 22 |             counter
 23 |             show-size
 24 |             chips
 25 |             small-chips
 26 |             truncate-length="15"
 27 |             accept=".html"
 28 |             label="Upload Template"
 29 |             @input="readFile"
 30 |             @change="readFile"
 31 |           />
 32 |         </v-col>
 33 |         <v-col>
 34 |           <v-text-field v-model="templateName" label="Template name" />
 35 |         </v-col>
 36 |       </v-row>
 37 |       <v-textarea
 38 |         v-model="plainText"
 39 |         name="input-7-1"
 40 |         label="Plain Text"
 41 |         placeholder="Input Plain text for the template"
 42 |       />
 43 |       <v-checkbox
 44 |         v-model="makePublic"
 45 |         label="Make this public for others to re-use"
 46 |       />
 47 |       <v-btn elevation="2" outlined @click="upload">
 48 |         Upload template
 49 |       </v-btn>
 50 |     </div>
 51 |     <div v-html="template" />
 52 |   </div>
 53 | </template>
 54 | 
 55 | <script>
 56 | export default {
 57 |   layout: 'dashboard',
 58 |   data () {
 59 |     return {
 60 |       template: null,
 61 |       file: null,
 62 |       templateName: null,
 63 |       plainText: null,
 64 |       makePublic: true
 65 |     }
 66 |   },
 67 |   head: {
 68 |     title: 'Upload template'
 69 |   },
 70 |   methods: {
 71 |     readFile () {
 72 |       const formData = new FormData()
 73 |       formData.append('file', this.file)
 74 |       this.$axios
 75 |         .post('/api/templates/readTemplate', formData, {
 76 |           headers: {
 77 |             'Content-Type': 'multipart/form-data'
 78 |           }
 79 |         })
 80 |         .then((response) => {
 81 |           this.template = response.data.template
 82 |           this.templateName = this.file.name.split('.')[0]
 83 |         })
 84 |         .catch((error) => {
 85 |           this.$store.commit('systemConfig/SNACKBAR', {
 86 |             show: true,
 87 |             type: 'danger',
 88 |             text: error.message
 89 |           })
 90 |         })
 91 |     },
 92 |     upload () {
 93 |       this.$axios
 94 |         .post('/api/templates/createTemplate', {
 95 |           content: this.template,
 96 |           name: this.templateName,
 97 |           likes: 0,
 98 |           user: JSON.parse(localStorage.getItem('user'))._id,
 99 |           plainText: this.plainText,
100 |           public: this.makePublic
101 |         })
102 |         .then((response) => {
103 |           this.$store.commit('systemConfig/SNACKBAR', {
104 |             show: true,
105 |             type: 'success',
106 |             text: response.data.message
107 |           })
108 |           this.$router.push('/templates')
109 |         })
110 |         .catch((error) => {
111 |           this.$store.commit('systemConfig/SNACKBAR', {
112 |             show: true,
113 |             type: 'danger',
114 |             text: error.message
115 |           })
116 |         })
117 |     }
118 |   }
119 | }
120 | </script>
121 | 


--------------------------------------------------------------------------------
/nuxt.config.js:
--------------------------------------------------------------------------------
  1 | // eslint-disable-next-line nuxt/no-cjs-in-config
  2 | import MonacoWebpackPlugin from 'monaco-editor-webpack-plugin'
  3 | 
  4 | export default {
  5 |   // Global page headers: https://go.nuxtjs.dev/config-head
  6 |   head: {
  7 |     titleTemplate: '%s - G-Notify',
  8 |     title: 'G-Notify',
  9 |     meta: [
 10 |       { charset: 'utf-8' },
 11 |       { name: 'viewport', content: 'width=device-width, initial-scale=1' },
 12 |       { hid: 'description', name: 'description', content: '' },
 13 |       { name: 'format-detection', content: 'telephone=no' }
 14 |     ],
 15 |     link: [
 16 |       { rel: 'icon', type: 'image/x-icon', href: '/favicon.ico' },
 17 |       { rel: 'preconnect', href: 'https://fonts.googleapis.com' },
 18 |       { rel: 'preconnect', href: 'https://fonts.gstatic.com', crossOriginIsolated: true },
 19 |       { rel: 'stylesheet', href: 'https://fonts.googleapis.com/css2?family=Open+Sans:ital,wght@0,300;0,400;0,500;0,600;0,700;0,800;1,300;1,400;1,500;1,600;1,700;1,800&family=Prata&display=swap' }
 20 |     ]
 21 |   },
 22 | 
 23 |   // router config
 24 |   router: {
 25 |     middleware: ['auth']
 26 |   },
 27 | 
 28 |   // Express server settings
 29 |   serverMiddleware: {
 30 |     '/api': '~/api'
 31 |   },
 32 | 
 33 |   // Global CSS: https://go.nuxtjs.dev/config-css
 34 |   css: [
 35 |     '@/assets/global.scss'
 36 |   ],
 37 | 
 38 |   // Plugins to run before rendering page: https://go.nuxtjs.dev/config-plugins
 39 |   plugins: [{ src: '~plugins/editor', mode: 'client' }, { src: '~plugins/prisma-highlight', mode: 'client' }],
 40 | 
 41 |   // Auto import components: https://go.nuxtjs.dev/config-components
 42 |   components: true,
 43 | 
 44 |   // Modules for dev and build (recommended): https://go.nuxtjs.dev/config-modules
 45 |   buildModules: [
 46 |     // https://go.nuxtjs.dev/eslint
 47 |     '@nuxtjs/eslint-module',
 48 |     // https://go.nuxtjs.dev/vuetify
 49 |     '@nuxtjs/vuetify'
 50 |   ],
 51 | 
 52 |   // Modules: https://go.nuxtjs.dev/config-modules
 53 |   modules: [
 54 |     // https://go.nuxtjs.dev/axios
 55 |     '@nuxtjs/axios',
 56 |     // https://go.nuxtjs.dev/pwa
 57 |     '@nuxtjs/pwa',
 58 |     // https://go.nuxtjs.dev/content
 59 |     '@nuxt/content',
 60 |     [
 61 |       'nuxt-highlightjs',
 62 |       {
 63 |         style: 'base16/zenburn'
 64 |       }
 65 |     ]
 66 |   ],
 67 | 
 68 |   // Axios module configuration: https://go.nuxtjs.dev/config-axios
 69 |   axios: {
 70 |     baseURL: process.env.BASEURL
 71 |   },
 72 | 
 73 |   // PWA module configuration: https://go.nuxtjs.dev/pwa
 74 |   pwa: {
 75 |     manifest: {
 76 |       lang: 'en'
 77 |     }
 78 |   },
 79 | 
 80 |   // Content module configuration: https://go.nuxtjs.dev/config-content
 81 |   content: {},
 82 | 
 83 |   // Vuetify module configuration: https://go.nuxtjs.dev/config-vuetify
 84 |   // <v-btn @click='$vuetify.theme.dark=!$vuetify.theme.dark'>Toggle Theme</v-btn>
 85 |   vuetify: {
 86 |     customVariables: ['~/assets/variables.scss'],
 87 |     theme: {
 88 |       dark: true,
 89 |       themes: {
 90 |         dark: {
 91 |           primary: '#4285F4',
 92 |           accent: '#42A5F5',
 93 |           secondary: '#2196F3',
 94 |           info: '#81C784',
 95 |           warning: '#FBBC04',
 96 |           error: '#EA4335',
 97 |           success: '#34A853'
 98 |         },
 99 |         light: {
100 |           primary: '#4285F4',
101 |           accent: '#42A5F5',
102 |           secondary: '#2196F3',
103 |           info: '#81C784',
104 |           warning: '#FBBC04',
105 |           error: '#EA4335',
106 |           success: '#34A853'
107 |         }
108 |       }
109 |     }
110 |   },
111 | 
112 |   // Build Configuration: https://go.nuxtjs.dev/config-build
113 |   build: {
114 |     plugins: [new MonacoWebpackPlugin()]
115 |   },
116 | 
117 |   watch: ['~/api/*.js', '~/api/*/*.js']
118 | }
119 | 


--------------------------------------------------------------------------------
/components/embed.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <v-card>
  3 |     <v-toolbar
  4 |       color="primary"
  5 |       dark
  6 |     >
  7 |       Embed image(s)
  8 |     </v-toolbar>
  9 |     <v-card-text>
 10 |       <v-file-input
 11 |         v-model="files"
 12 |         chips
 13 |         counter
 14 |         multiple
 15 |         show-size
 16 |         truncate-length="20"
 17 |         accept="image/*"
 18 |       />
 19 |       <v-btn @click="upload">
 20 |         upload
 21 |       </v-btn>
 22 |       <br><br>
 23 |       <AceEditor
 24 |         v-model="content"
 25 |         disabled
 26 |         lang="html"
 27 |         theme="monokai"
 28 |         width="100%"
 29 |         height="15vh"
 30 |         :options="{
 31 |           enableBasicAutocompletion: true,
 32 |           enableLiveAutocompletion: true,
 33 |           fontSize: 14,
 34 |           highlightActiveLine: true,
 35 |           enableSnippets: true,
 36 |           showLineNumbers: true,
 37 |           tabSize: 2,
 38 |           showPrintMargin: false,
 39 |           showGutter: true
 40 |         }"
 41 |         @init="editorInit"
 42 |       />
 43 |     </v-card-text>
 44 |     <v-card-actions class="justify-end">
 45 |       <v-btn v-if="requestComplete" @click="copyEmbedScript">
 46 |         copy
 47 |       </v-btn>
 48 |       <v-btn
 49 |         text
 50 |         @click="$emit('exit')"
 51 |       >
 52 |         Close
 53 |       </v-btn>
 54 |     </v-card-actions>
 55 |   </v-card>
 56 | </template>
 57 | 
 58 | <script>
 59 | import { mapGetters } from 'vuex'
 60 | 
 61 | let AceEditor
 62 | if (process.client) {
 63 |   AceEditor = require('vue2-ace-editor')
 64 | }
 65 | export default {
 66 |   components: {
 67 |     AceEditor
 68 |   },
 69 |   data () {
 70 |     return { content: '<img src="embed link" />', files: [], requestComplete: false }
 71 |   },
 72 |   computed: {
 73 |     ...mapGetters({
 74 |       user: 'auth/user'
 75 |     })
 76 |   },
 77 |   methods: {
 78 |     dataSumit () {
 79 |     // code here
 80 |     },
 81 |     copyEmbedScript () {
 82 |       navigator.clipboard.writeText(this.content)
 83 |     },
 84 |     editorInit () {
 85 |       require('brace/ext/language_tools') // language extension prerequsite...
 86 |       require('brace/mode/html')
 87 |       require('brace/mode/javascript') // language
 88 |       require('brace/mode/less')
 89 |       require('brace/theme/monokai')
 90 |       require('brace/snippets/javascript') // snippet
 91 |     },
 92 |     upload () {
 93 |       const formData = new FormData()
 94 |       this.files.forEach((file) => {
 95 |         formData.append('files', file)
 96 |       })
 97 |       const self = this
 98 |       this.$axios
 99 |         .post('/api/files/upload', formData, {
100 |           headers: {
101 |             'Content-Type': 'multipart/form-data'
102 |           },
103 |           params: {
104 |             user: this.user.id
105 |           }
106 |         })
107 |         .then((response) => {
108 |           const len = this.files.length
109 |           const promises = []
110 |           for (let i = 0; i < len; i++) {
111 |             const { path } = response.data.pop()
112 |             promises.push(self.$axios.get('api/files/get-embed-link', {
113 |               params: { path, days: 10 }
114 |             }))
115 |           }
116 |           Promise.all(promises).then((responseLink) => {
117 |             self.content = responseLink.map((link) => {
118 |               return `<img src="${link.data[0]}" />`
119 |             }).join('\n')
120 |           })
121 |           this.requestComplete = true
122 |         })
123 |         .catch((error) => {
124 |           this.$store.commit('systemConfig/SNACKBAR', {
125 |             show: true,
126 |             type: 'danger',
127 |             text: error.message
128 |           })
129 |         })
130 |     }
131 |   }
132 | }
133 | </script>
134 | 
135 | <style>
136 | 
137 | </style>
138 | 


--------------------------------------------------------------------------------
/api/routes/emails.routes.js:
--------------------------------------------------------------------------------
  1 | // Emailing related routes go here
  2 | 
  3 | const path = require('path')
  4 | const dir = path.join(path.resolve(path.dirname('')), 'api')
  5 | const router = require('express').Router()
  6 | const multer = require('multer')
  7 | const dbFunction = require('../controllers/db.controller')
  8 | const emailFunction = require('../controllers/gmail.controller')
  9 | const fileHandler = require('../controllers/fileHandler.controller')
 10 | 
 11 | const storage = multer.diskStorage({
 12 |   destination: `${dir}/upload`,
 13 |   // overwriting the filename with an inline function to replace spaces to '-', making it better for URLs
 14 |   filename: (_, file, cb) => {
 15 |     cb(null, file.originalname.replace(' ', '-'))
 16 |   }
 17 | })
 18 | 
 19 | const upload = multer({
 20 |   storage
 21 | })
 22 | 
 23 | router.get('/sendTest', async (req, res) => {
 24 |   const userId = req.query.user
 25 |   const templateId = req.query.template
 26 |   const user = await dbFunction.getUserDataById(userId)
 27 |   // console.log(user)
 28 |   const template = await dbFunction.getTemplate(templateId)
 29 |   try {
 30 |     emailFunction.sendSingleMessage(
 31 |       JSON.stringify(user.token),
 32 |       template.content,
 33 |       user.user.email,
 34 |       user.user.email,
 35 |       'Test Email from G-Notify',
 36 |       'plainText'
 37 |     )
 38 |   } catch (err) {
 39 |     // console.log(err)
 40 |   }
 41 |   res.send('Email sent')
 42 | })
 43 | 
 44 | router.post('/importExcel', upload.single('excel'), async (req, res) => {
 45 |   try {
 46 |     const list = await fileHandler.readExcel(
 47 |       req.file.path
 48 |         .split('/')
 49 |         .pop()
 50 |         .replace(' ', '+')
 51 |     )
 52 |     return res.status(200).send({ list })
 53 |   } catch (err) {
 54 |     console.log(err)
 55 |     return res.status(500).send({ err })
 56 |   }
 57 | })
 58 | 
 59 | router.post('/sendEmails', async (req, res) => {
 60 |   const { templateId, subject, emails, tracking } = req.body
 61 |   const template = await dbFunction.getTemplate(templateId)
 62 |   const user = await dbFunction.getUserDataById(req.query.userId)
 63 |   const email = await dbFunction.createEmail(
 64 |     templateId,
 65 |     user.user.email,
 66 |     emails,
 67 |     subject
 68 |   )
 69 |   if (tracking) {
 70 |     try {
 71 |       const promises = emails.map(emailId =>
 72 |         emailFunction.sendSingleMessage(
 73 |           JSON.stringify(user.token),
 74 |           template.content +
 75 |             `<img src="${process.env.DOMAIN}/api/tracking/${email._id}/${emailId}" />`,
 76 |           emailId,
 77 |           user.email,
 78 |           subject,
 79 |           template.plainText
 80 |         )
 81 |       )
 82 |       await Promise.all(promises)
 83 |       return res
 84 |         .status(200)
 85 |         .send({ message: 'Emails sent with tracking', emailId: email._id })
 86 |     } catch (err) {
 87 |       console.log(err)
 88 |       return res.status(500).send({ err })
 89 |     }
 90 |   }
 91 |   try {
 92 |     await emailFunction.sendMultipleMails(
 93 |       JSON.stringify(user.token),
 94 |       template.content,
 95 |       emails,
 96 |       user.user.email,
 97 |       subject,
 98 |       template.plainText
 99 |     )
100 |     return res.status(200).send({ message: 'Emails sent', emailId: email._id })
101 |   } catch (err) {
102 |     console.log(err)
103 |     return res.status(500).send({ err })
104 |   }
105 | })
106 | 
107 | router.get('/list/:user', async (req, res) => {
108 |   const emails = await dbFunction.getEmailsByUser(req.params.user)
109 |   return res.status(200).send({ emails })
110 | })
111 | 
112 | router.get('/:id', async (req, res) => {
113 |   const email = await dbFunction.getEmailById(req.params.id)
114 |   return res.status(200).send({ email })
115 | })
116 | 
117 | router.get('/stats/all', async (req, res) => {
118 |   const totalCount = await dbFunction.getTotalEmailStats()
119 |   const readCount = await dbFunction.getReadEmailStats()
120 |   return res.status(200).send({ totalCount, readCount })
121 | })
122 | 
123 | module.exports = router
124 | 


--------------------------------------------------------------------------------
/components/templateCard.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <v-card
  3 |     style="margin: 0.3rem; display: flex; flex-direction: column; justify-content: space-between;"
  4 |   >
  5 |     <img
  6 |       :src="`/api/templates/renderTemplate?quality=low&id=${id}`"
  7 |       alt="rendered-out"
  8 |     >
  9 |     <div>
 10 |       <v-card-title>{{ name }}</v-card-title>
 11 |       <v-card-text class="text--primary">
 12 |         {{ desc }}
 13 |       </v-card-text>
 14 |       <v-card-actions class="action-bar">
 15 |         <div>
 16 |           <v-chip
 17 |             class="ma-2"
 18 |             color="blue-grey"
 19 |             label
 20 |             text-color="white"
 21 |             @click="addLike(id)"
 22 |           >
 23 |             <v-icon left>
 24 |               mdi-thumb-up-outline
 25 |             </v-icon>
 26 |             {{ likes }}
 27 |           </v-chip>
 28 |           <v-btn icon @click="$router.push(`/templates/create/${id}`)">
 29 |             <v-icon>mdi-pencil</v-icon>
 30 |           </v-btn>
 31 |           <v-dialog v-model="dialog">
 32 |             <template #activator="{ on, attrs }">
 33 |               <v-btn icon v-bind="attrs" v-on="on">
 34 |                 <v-icon>mdi-code-tags</v-icon>
 35 |               </v-btn>
 36 |             </template>
 37 |             <v-card>
 38 |               <pre class="language-html">
 39 |                 <code v-highlight="templateContent" />
 40 |               </pre>
 41 |             </v-card>
 42 |           </v-dialog>
 43 |         </div>
 44 | 
 45 |         <div>
 46 |           <v-btn color="blue" text @click="$router.push(`/emails/send/${id}`)">
 47 |             Use
 48 |           </v-btn>
 49 |           <v-btn
 50 |             outlined
 51 |             color="primary"
 52 |             elevation="2"
 53 |             small
 54 |             @click="sendTest"
 55 |           >
 56 |             Test
 57 |           </v-btn>
 58 |         </div>
 59 |       </v-card-actions>
 60 |     </div>
 61 |   </v-card>
 62 | </template>
 63 | 
 64 | <script>
 65 | import { mapGetters } from 'vuex'
 66 | export default {
 67 |   props: {
 68 |     templateUser: {
 69 |       type: Object,
 70 |       required: true
 71 |     },
 72 |     templateContent: {
 73 |       type: String,
 74 |       required: true
 75 |     },
 76 |     id: {
 77 |       type: String,
 78 |       required: true
 79 |     },
 80 |     name: {
 81 |       type: String,
 82 |       required: true
 83 |     },
 84 |     desc: {
 85 |       type: String,
 86 |       required: true
 87 |     },
 88 |     likes: {
 89 |       type: Number,
 90 |       required: true
 91 |     }
 92 |   },
 93 |   data () {
 94 |     return {
 95 |       dialog: false,
 96 |       src: null
 97 |     }
 98 |   },
 99 |   computed: {
100 |     ...mapGetters({
101 |       user: 'auth/user'
102 |     })
103 |   },
104 |   methods: {
105 |     sendTest () {
106 |       this.$axios
107 |         .get('/api/emails/sendTest', {
108 |           params: {
109 |             template: this.id,
110 |             user: this.user.id
111 |           }
112 |         })
113 |         .then((response) => {
114 |           this.$store.commit('systemConfig/SNACKBAR', {
115 |             show: true,
116 |             type: 'success',
117 |             text: 'Email sent to your email id'
118 |           })
119 |         })
120 |         .catch((error) => {
121 |           this.$store.commit('systemConfig/SNACKBAR', {
122 |             show: true,
123 |             type: 'danger',
124 |             text: error.message
125 |           })
126 |         })
127 |     },
128 |     toBase64 (arr) {
129 |       return btoa(
130 |         arr.reduce((data, byte) => data + String.fromCharCode(byte), '')
131 |       )
132 |     },
133 |     addLike (id) {
134 |       this.$axios.get(`/api/templates/${id}/like`).then((response) => {
135 |         this.$emit('updateLikes', response.data.likes)
136 |       })
137 |     }
138 |   }
139 | }
140 | </script>
141 | 
142 | <style scoped lang="scss">
143 | img {
144 |   width: 100%;
145 |   height: 250px;
146 |   object-fit: cover;
147 | }
148 | 
149 | .action-bar {
150 |   display: flex;
151 |   justify-content: space-between;
152 |   align-items: center;
153 | }
154 | </style>
155 | 


--------------------------------------------------------------------------------
/pages/templates/create/_id.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <div class="container">
  3 |     <v-alert
  4 |       dense
  5 |       icon="mdi-information"
  6 |       text
  7 |       type="info"
  8 |       color="blue"
  9 |     >
 10 |       While creating the template preferably put all your CSS in a style inside the body or make it inline.
 11 |     </v-alert>
 12 |     <v-alert
 13 |       dense
 14 |       icon="mdi-alert-circle-outline"
 15 |       text
 16 |       type="error"
 17 |       color="red"
 18 |     >
 19 |       The rendered version on the right side isn't an accurate representaion of what the email will look like.
 20 |     </v-alert>
 21 |     <v-row style="margin: 1rem 0; display: flex; justify-content: space-between;">
 22 |       <v-col>
 23 |         <v-btn color="danger" text @click="content = ''">
 24 |           clear
 25 |         </v-btn>
 26 |         <v-btn color="primary" text @click="$router.push('/templates/rules')">
 27 |           Templating Rules
 28 |         </v-btn><br><br>
 29 |         <v-dialog
 30 |           transition="dialog-bottom-transition"
 31 |           max-width="600"
 32 |         >
 33 |           <template #activator="{ on, attrs }">
 34 |             <v-btn
 35 |               v-bind="attrs"
 36 |               v-on="on"
 37 |             >
 38 |               Embed Image(s)
 39 |             </v-btn>
 40 |           </template>
 41 |           <template #default="dialog">
 42 |             <Embed @exit="dialog.value = false;" />
 43 |           </template>
 44 |         </v-dialog>
 45 |       </v-col>
 46 |       <v-col style="display: flex;">
 47 |         <v-text-field v-model="templateName" label="Template name" />
 48 |         <v-btn color="primary">
 49 |           Test
 50 |         </v-btn>
 51 |         <v-btn color="primary" outlined @click="upload">
 52 |           Create
 53 |         </v-btn>
 54 |       </v-col>
 55 |     </v-row>
 56 |     <v-row no-gutters>
 57 |       <v-col>
 58 |         <client-only>
 59 |           <MonacoEditor
 60 |             :options="options"
 61 |             custom-class="myClass"
 62 |             custom-style="height:500px"
 63 |             @onChange="onChange"
 64 |           />
 65 |         </client-only>
 66 |       </v-col>
 67 |       <v-col style="overflow: hidden">
 68 |         <iframe :srcdoc="content" frameborder="0" />
 69 |       </v-col>
 70 |     </v-row>
 71 |   </div>
 72 | </template>
 73 | 
 74 | <script>
 75 | export default {
 76 |   layout: 'dashboard',
 77 |   async asyncData ({ params, $axios }) {
 78 |     const id = params.id
 79 |     const data = await $axios.$get(`/api/templates/${id}`)
 80 |     const template = data.template
 81 |     return {
 82 |       templateName: template.name,
 83 |       options: {
 84 |         value: template.content,
 85 |         language: 'html',
 86 |         fontSize: '13px',
 87 |         automaticLayout: true,
 88 |         theme: 'vs-dark',
 89 |         roundedSelection: false,
 90 |         scrollBeyondLastLine: false,
 91 |         minimap: false
 92 |       }
 93 |     }
 94 |   },
 95 |   head: {
 96 |     title: 'Upload template'
 97 |   },
 98 |   computed: {
 99 |     content () {
100 |       return `<html><head><style>body { color-scheme: light !important; background: white !important; }</style></head><body>${this.options.value}</body></html>`
101 |     }
102 |   },
103 |   methods: {
104 |     onChange (newValue) {
105 |       this.options.value = newValue.value
106 |     },
107 |     upload () {
108 |       this.$axios.post('/api/templates/createTemplate', {
109 |         content: this.options.value,
110 |         name: this.templateName,
111 |         likes: 0,
112 |         user: JSON.parse(localStorage.getItem('user'))._id
113 |       })
114 |         .then((response) => {
115 |           this.$store.commit('systemConfig/SNACKBAR', {
116 |             show: true,
117 |             type: 'success',
118 |             text: response.data.message
119 |           })
120 |           this.$router.push('/templates')
121 |         })
122 |         .catch((error) => {
123 |           this.$store.commit('systemConfig/SNACKBAR', {
124 |             show: true,
125 |             type: 'danger',
126 |             text: error.message
127 |           })
128 |         })
129 |     }
130 |   }
131 | }
132 | </script>
133 | 
134 | <style scoped lang="css">
135 | iframe {
136 |   width: 100%;
137 |   height: 100%;
138 |   color-scheme: light;
139 | }
140 | </style>
141 | 


--------------------------------------------------------------------------------
/pages/templates/create/index.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <div class="container">
  3 |     <v-alert dense icon="mdi-information" text type="info" color="blue">
  4 |       While creating the template preferably put all your CSS in a style inside
  5 |       the body or make it inline.
  6 |     </v-alert>
  7 |     <v-alert
  8 |       dense
  9 |       icon="mdi-alert-circle-outline"
 10 |       text
 11 |       type="error"
 12 |       color="red"
 13 |     >
 14 |       The rendered version on the right side isn't an accurate representaion of
 15 |       what the email will look like.
 16 |     </v-alert>
 17 |     <v-row
 18 |       style="margin: 1rem 0; display: flex; justify-content: space-between;"
 19 |     >
 20 |       <v-col>
 21 |         <v-btn color="danger" text @click="content = ''">
 22 |           clear
 23 |         </v-btn>
 24 |         <v-btn color="primary" text @click="$router.push('/templates/rules')">
 25 |           Templating Rules
 26 |         </v-btn><br><br>
 27 |         <v-dialog
 28 |           transition="dialog-bottom-transition"
 29 |           max-width="600"
 30 |         >
 31 |           <template #activator="{ on, attrs }">
 32 |             <v-btn
 33 |               v-bind="attrs"
 34 |               v-on="on"
 35 |             >
 36 |               Embed Image(s)
 37 |             </v-btn>
 38 |           </template>
 39 |           <template #default="dialog">
 40 |             <Embed @exit="dialog.value = false;" />
 41 |           </template>
 42 |         </v-dialog>
 43 |       </v-col>
 44 |       <v-col>
 45 |         <v-row>
 46 |           <v-text-field v-model="templateName" label="Template name" />
 47 |           <v-btn color="primary">
 48 |             Test
 49 |           </v-btn>
 50 |           <v-btn color="primary" outlined style="margin-left: 0.3rem" @click="upload">
 51 |             Create
 52 |           </v-btn>
 53 |         </v-row>
 54 |         <v-row>
 55 |           <v-checkbox
 56 |             v-model="makePublic"
 57 |             label="Make this public for others to re-use"
 58 |           />
 59 |         </v-row>
 60 |       </v-col>
 61 |     </v-row>
 62 |     <v-row no-gutters>
 63 |       <v-col>
 64 |         <client-only>
 65 |           <MonacoEditor
 66 |             :options="options"
 67 |             custom-class="myClass"
 68 |             custom-style="height:500px"
 69 |             @onChange="onChange"
 70 |           />
 71 |         </client-only>
 72 |       </v-col>
 73 |       <v-col style="overflow: hidden">
 74 |         <iframe :srcdoc="content" frameborder="0" />
 75 |       </v-col>
 76 |     </v-row>
 77 |   </div>
 78 | </template>
 79 | 
 80 | <script>
 81 | import Embed from '@/components/embed'
 82 | export default {
 83 |   components: {
 84 |     Embed
 85 |   },
 86 |   layout: 'dashboard',
 87 |   data () {
 88 |     return {
 89 |       templateName: null,
 90 |       options: {
 91 |         value: `<h1>Hello</h1>
 92 | <h3>This is what your mail might look like</h3>
 93 | <p> 
 94 |     But there are major rules when it comes html on emails. <br>
 95 |     <a href="/templates/rules" target="_blank">Here</a> is a guide to the same
 96 | </p>`,
 97 |         language: 'html',
 98 |         fontSize: '13px',
 99 |         automaticLayout: true,
100 |         theme: 'vs-dark',
101 |         roundedSelection: false,
102 |         scrollBeyondLastLine: false,
103 |         minimap: false
104 |       },
105 |       makePublic: true
106 |     }
107 |   },
108 |   head: {
109 |     title: 'Upload template'
110 |   },
111 |   computed: {
112 |     content () {
113 |       return `<html><head><style>body { color-scheme: light !important; background: white !important; }</style></head><body>${this.options.value}</body></html>`
114 |     }
115 |   },
116 |   methods: {
117 |     onChange (newValue) {
118 |       this.options.value = newValue.value
119 |     },
120 |     upload () {
121 |       this.$axios
122 |         .post('/api/templates/createTemplate', {
123 |           content: this.options.value,
124 |           name: this.templateName,
125 |           likes: 0,
126 |           user: JSON.parse(localStorage.getItem('user'))._id,
127 |           public: this.makePublic
128 |         })
129 |         .then((response) => {
130 |           this.$store.commit('systemConfig/SNACKBAR', {
131 |             show: true,
132 |             type: 'success',
133 |             text: response.data.message
134 |           })
135 |           this.$router.push('/templates')
136 |         })
137 |         .catch((error) => {
138 |           this.$store.commit('systemConfig/SNACKBAR', {
139 |             show: true,
140 |             type: 'danger',
141 |             text: error.message
142 |           })
143 |         })
144 |     }
145 |   }
146 | }
147 | </script>
148 | 
149 | <style lang="css">
150 | iframe {
151 |   width: 100%;
152 |   height: 100%;
153 |   color-scheme: light;
154 | }
155 | </style>
156 | 


--------------------------------------------------------------------------------
/pages/emails/send/_id.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <div class="container">
  3 |     <v-row>
  4 |       <v-col cols="6">
  5 |         <v-alert
  6 |           color="red"
  7 |           dense
  8 |           icon="mdi-alert-circle-outline"
  9 |           text
 10 |           type="error"
 11 |         >
 12 |           The preview is rendered using a headless browser hence looks slightly
 13 |           different from the real website.
 14 |         </v-alert>
 15 |         <h1>Send Template</h1>
 16 |         <h4 style="margin-bottom: 1rem">
 17 |           Template: {{ template.name }}
 18 |         </h4>
 19 |         <v-row class="form-row">
 20 |           <v-text-field
 21 |             v-model="email"
 22 |             class="mx-2"
 23 |             label="Email"
 24 |             required
 25 |             @keydown.enter="emails.push(email)"
 26 |           />
 27 |           <v-btn
 28 |             color="success"
 29 |             class="mx-2"
 30 |             type="submit"
 31 |             @click="dialog = true"
 32 |           >
 33 |             Import
 34 |           </v-btn>
 35 |           <v-btn
 36 |             color="primary"
 37 |             class="mx-2"
 38 |             type="submit"
 39 |             @click="emails.push(email)"
 40 |           >
 41 |             Add
 42 |           </v-btn>
 43 |         </v-row>
 44 |         <br>
 45 |         <v-text-field v-model="subject" class="mx-2" label="Subject" required />
 46 |         <br>
 47 |         <v-checkbox
 48 |           v-model="enableTracking"
 49 |           label="Add tracking"
 50 |         />
 51 |         <br>
 52 |         <v-btn color="primary" class="mx-2" type="submit" @click="send">
 53 |           Send
 54 |         </v-btn>
 55 |         <v-simple-table v-if="emails.length > 0">
 56 |           <template #default>
 57 |             <thead>
 58 |               <tr>
 59 |                 <th class="text-left">
 60 |                   Email
 61 |                 </th>
 62 |                 <th class="text-left">
 63 |                   Action
 64 |                 </th>
 65 |               </tr>
 66 |             </thead>
 67 |             <tbody>
 68 |               <tr v-for="(item, index) in emails" :key="item.name">
 69 |                 <td>{{ item }}</td>
 70 |                 <td>
 71 |                   <v-btn
 72 |                     color="red"
 73 |                     plain
 74 |                     elevation="0"
 75 |                     @click="emails.splice(index, 1)"
 76 |                   >
 77 |                     Remove
 78 |                   </v-btn>
 79 |                 </td>
 80 |               </tr>
 81 |             </tbody>
 82 |           </template>
 83 |         </v-simple-table>
 84 |       </v-col>
 85 |       <v-col
 86 |         cols="6"
 87 |         style="height: 85vh; overflow-y: scroll;"
 88 |         v-html="template.content"
 89 |       />
 90 |     </v-row>
 91 |     <v-dialog v-model="dialog" width="500">
 92 |       <v-card>
 93 |         <v-card-title class="text-h5 grey lighten-2">
 94 |           Import Excel
 95 |         </v-card-title>
 96 | 
 97 |         <v-card-text>
 98 |           <v-file-input
 99 |             v-model="excel"
100 |             counter
101 |             show-size
102 |             accept="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
103 |             placeholder="Upload xlsx file"
104 |           />
105 |         </v-card-text>
106 | 
107 |         <v-divider />
108 | 
109 |         <v-card-actions>
110 |           <v-spacer />
111 |           <v-btn color="primary" text @click="importExcel">
112 |             Import
113 |           </v-btn>
114 |         </v-card-actions>
115 |       </v-card>
116 |     </v-dialog>
117 |     <v-dialog v-model="loader" hide-overlay persistent width="300">
118 |       <v-card color="primary" dark>
119 |         <v-card-text>
120 |           Processing Excel
121 |           <v-progress-linear indeterminate color="white" class="mb-0" />
122 |         </v-card-text>
123 |       </v-card>
124 |     </v-dialog>
125 |   </div>
126 | </template>
127 | 
128 | <script>
129 | export default {
130 |   layout: 'dashboard',
131 |   asyncData: async ({ params, $axios }) => {
132 |     const templateId = params.id
133 |     const tempData = await $axios.get(`/api/templates/${templateId}`)
134 |     return {
135 |       template: tempData.data.template
136 |     }
137 |   },
138 |   data () {
139 |     return {
140 |       email: null,
141 |       emails: [],
142 |       excel: null,
143 |       dialog: false,
144 |       loader: false,
145 |       subject: null,
146 |       enableTracking: false
147 |     }
148 |   },
149 |   head: {
150 |     title: 'Send Email'
151 |   },
152 |   methods: {
153 |     importExcel () {
154 |       this.dialog = false
155 |       this.loader = true
156 |       const formData = new FormData()
157 |       formData.append('excel', this.excel)
158 |       this.$axios
159 |         .post('/api/emails/importExcel', formData)
160 |         .then((res) => {
161 |           console.log(res.data)
162 |           this.emails = res.data.list
163 |           this.loader = false
164 |         })
165 |         .catch((err) => {
166 |           console.log(err)
167 |           this.loader = false
168 |         })
169 |     },
170 |     send () {
171 |       const userId = JSON.parse(localStorage.getItem('user'))._id
172 |       this.$axios
173 |         .post('/api/emails/sendEmails?userId=' + userId, {
174 |           emails: this.emails,
175 |           templateId: this.$route.params.id,
176 |           subject: this.subject,
177 |           tracking: this.enableTracking
178 |         })
179 |         .then((res) => {
180 |           console.log(res.data)
181 |         })
182 |         .catch((err) => {
183 |           console.log(err)
184 |         })
185 |     }
186 |   }
187 | }
188 | </script>
189 | 


--------------------------------------------------------------------------------
/api/controllers/gmail.controller.js:
--------------------------------------------------------------------------------
  1 | // Google APIs go here
  2 | const fs = require('fs')
  3 | const { google } = require('googleapis')
  4 | const { createMimeMessage } = require('mimetext')
  5 | const IMAGE_EXT = ['jpg', 'jpeg', 'png', 'gif', 'ico', 'bmp']
  6 | const PDF_EXT = ['pdf']
  7 | const OTHER_TYPES = {
  8 |   csv: 'text/csv',
  9 |   csv1: 'application/csv',
 10 |   json: 'application/json',
 11 |   txt: 'text/plain',
 12 |   xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
 13 |   xlsb: 'application/vnd.ms-excel.sheet.binary.macroEnabled.12',
 14 |   xls: 'application/vnd.ms-excel',
 15 |   xlsm: 'application/vnd.ms-excel.sheet.macroEnabled.12',
 16 |   doc: 'application/msword',
 17 |   docm: 'application/vnd.ms-word.document.macroEnabled.12',
 18 |   docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
 19 |   dotx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
 20 |   dotm: 'application/vnd.ms-word.template.macroEnabled.12',
 21 |   html: 'text/html',
 22 |   pdf: 'application/pdf',
 23 |   potm: 'application/vnd.ms-powerpoint.template.macroEnabled.12',
 24 |   potx: 'application/vnd.openxmlformats-officedocument.presentationml.template',
 25 |   ppam: 'application/vnd.ms-powerpoint.addin.macroEnabled.12',
 26 |   pps: 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
 27 |   ppsx: 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
 28 |   ppsm: 'application/vnd.ms-powerpoint.slideshow.macroEnabled.12',
 29 |   ppt: 'application/vnd.ms-powerpoint',
 30 |   pptm: 'application/vnd.ms-powerpoint.presentation.macroEnabled.12',
 31 |   pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
 32 |   rtf: 'application/rtf',
 33 |   rtf2: 'text/rtf'
 34 | }
 35 | 
 36 | const SCOPES = [
 37 |   'https://www.googleapis.com/auth/gmail.send',
 38 |   'https://www.googleapis.com/auth/gmail.modify',
 39 |   'https://www.googleapis.com/auth/gmail.compose',
 40 |   'https://www.googleapis.com/auth/gmail.metadata'
 41 | ]
 42 | 
 43 | const AUTH_CLIENT = new google.auth.OAuth2(
 44 |   process.env.GMAIL_CLIENT_ID,
 45 |   process.env.GMAIL_CLIENT_SECRET,
 46 |   process.env.GMAIL_REDIRECT_URL
 47 | )
 48 | 
 49 | const getCredLink = () => {
 50 |   return new Promise((resolve, reject) => {
 51 |     const url = AUTH_CLIENT.generateAuthUrl({
 52 |       access_type: 'offline',
 53 |       scope: SCOPES
 54 |     })
 55 |     resolve(url)
 56 |   })
 57 | }
 58 | 
 59 | const getToken = (code) => {
 60 |   return new Promise((resolve, reject) => {
 61 |     AUTH_CLIENT.getToken(code, (err, token) => {
 62 |       if (err) {
 63 |         reject(err)
 64 |       }
 65 |       resolve(token)
 66 |     })
 67 |   })
 68 | }
 69 | 
 70 | const loadUser = (token) => {
 71 |   return new Promise((resolve, reject) => {
 72 |     AUTH_CLIENT.setCredentials(JSON.parse(token))
 73 |     const gmail = google.gmail({ version: 'v1' })
 74 |     gmail.users
 75 |       .getProfile({ userId: 'me', auth: AUTH_CLIENT })
 76 |       .then((response) => {
 77 |         resolve(response)
 78 |       })
 79 |       .catch(reject)
 80 |   })
 81 | }
 82 | 
 83 | const sendSingleMessage = (
 84 |   token,
 85 |   HTML = null,
 86 |   recipient,
 87 |   from,
 88 |   subject,
 89 |   plainText,
 90 |   userId = 'me',
 91 |   attachments = null
 92 | ) => {
 93 |   return new Promise((resolve, reject) => {
 94 |     const msg = createMail(
 95 |       HTML,
 96 |       from,
 97 |       subject,
 98 |       plainText,
 99 |       attachments,
100 |       reject)
101 |     msg.setTo(`<${recipient}>`)
102 | 
103 |     // console.log(msg.asRaw())
104 | 
105 |     const buffer = Buffer.from(msg.asRaw())
106 |     const base64SafeString = buffer.toString('base64')
107 |     AUTH_CLIENT.setCredentials(JSON.parse(token))
108 |     const gmail = google.gmail({ version: 'v1', auth: AUTH_CLIENT })
109 |     gmail.users.messages
110 |       .send({
111 |         userId,
112 |         requestBody: {
113 |           raw: base64SafeString
114 |         }
115 |       })
116 |       .then(resolve)
117 |       .catch(reject)
118 |   })
119 | }
120 | 
121 | const sendMultipleMails = (
122 |   token,
123 |   HTML = null,
124 |   recipients = [],
125 |   from,
126 |   subject,
127 |   plainText,
128 |   userId = 'me',
129 |   attachments = null
130 | ) => {
131 |   return new Promise((resolve, reject) => {
132 |     const msg = createMail(
133 |       HTML,
134 |       from,
135 |       subject,
136 |       plainText,
137 |       attachments,
138 |       reject)
139 |     msg.setTo(`<${recipients[0]}>`)
140 |     msg.setBcc(recipients.slice(1))
141 | 
142 |     const buffer = Buffer.from(msg.asRaw())
143 |     const base64SafeString = buffer.toString('base64')
144 |     AUTH_CLIENT.setCredentials(JSON.parse(token))
145 |     const gmail = google.gmail({ version: 'v1', auth: AUTH_CLIENT })
146 |     gmail.users.messages
147 |       .send({
148 |         userId,
149 |         requestBody: {
150 |           raw: base64SafeString
151 |         }
152 |       })
153 |       .then(resolve)
154 |       .catch(reject)
155 |   })
156 | }
157 | 
158 | module.exports = { getCredLink, getToken, sendSingleMessage, loadUser, sendMultipleMails }
159 | 
160 | // Non exported functions
161 | 
162 | const createMail = (
163 |   HTML = null,
164 |   from,
165 |   subject,
166 |   plainText,
167 |   attachments = null,
168 |   reject
169 | ) => {
170 |   const msg = createMimeMessage()
171 |   msg.setSender(`<${from}>`)
172 |   // msg.setBcc(['fgh@jkl.com', 'test2@test.com', { name: 'Name', addr: 'test3@test.com' }])
173 |   msg.setSubject(subject)
174 |   // add html version
175 |   if (HTML) { msg.setMessage('text/html', HTML) }
176 |   // add alternative plain text version
177 |   msg.setMessage('text/plain', plainText)
178 |   if (attachments) {
179 |     if (attachments.length) {
180 |       attachments.forEach((attachment) => {
181 |         const name = attachment.name
182 |         const extension = attachment.name.split('.').pop()
183 |         let mimeType = ''
184 |         if (IMAGE_EXT.includes(extension)) {
185 |           mimeType = 'image/' + extension
186 |         } else if (PDF_EXT.includes(extension)) {
187 |           mimeType = 'application/pdf'
188 |         } else if (OTHER_TYPES.keys().includes(extension)) {
189 |           mimeType = OTHER_TYPES[extension]
190 |         } else {
191 |           reject(Error('file format not supported'))
192 |         }
193 |         const file = fs.readFileSync(attachment.path, { encoding: 'base64' })
194 |         msg.addAttachment(name, mimeType, file)
195 |       })
196 |     }
197 |   }
198 |   return msg
199 | }
200 | 


--------------------------------------------------------------------------------
/api/controllers/db.controller.js:
--------------------------------------------------------------------------------
  1 | // Database functions
  2 | const mongoose = require('mongoose')
  3 | const userModel = require('../models/user.model')
  4 | const templateModel = require('../models/template.model')
  5 | const emailModel = require('../models/email.model')
  6 | const fileModel = require('../models/files.model')
  7 | const fileHandler = require('./fileHandler.controller')
  8 | 
  9 | const getUserData = (email, token) => {
 10 |   // console.log(email)
 11 |   return new Promise((resolve, reject) => {
 12 |     userModel.findOne({ 'user.email': email }, (err, data) => {
 13 |       if (err) {
 14 |         reject(err)
 15 |       } else if (!data) {
 16 |         resolve(null)
 17 |       } else {
 18 |         data.token = JSON.parse(token)
 19 |         userModel.findOneAndUpdate({ _id: data._id }, data, (err, data) => {
 20 |           if (err) {
 21 |             reject(err)
 22 |           } else {
 23 |             resolve(data)
 24 |           }
 25 |         })
 26 |       }
 27 |     })
 28 |   })
 29 | }
 30 | 
 31 | const getUserDataById = (id) => {
 32 |   // console.log(id)
 33 |   return new Promise((resolve, reject) => {
 34 |     userModel.findOne({ _id: id }, (err, data) => {
 35 |       if (err) {
 36 |         reject(err)
 37 |       } else {
 38 |         resolve(data)
 39 |       }
 40 |     })
 41 |   })
 42 | }
 43 | 
 44 | const createUser = (user, token) => {
 45 |   return new Promise((resolve, reject) => {
 46 |     userModel.create(
 47 |       { user, token, _id: mongoose.Types.ObjectId() },
 48 |       (err, data) => {
 49 |         if (err) {
 50 |           reject(err)
 51 |         } else {
 52 |           resolve(data)
 53 |         }
 54 |       }
 55 |     )
 56 |   })
 57 | }
 58 | 
 59 | const getTemplates = (start) => {
 60 |   return new Promise((resolve, reject) => {
 61 |     templateModel
 62 |       .find({ public: true }, null, { skip: Number(start) * 20, limit: 20 })
 63 |       .populate('user')
 64 |       .exec((err, template) => {
 65 |         if (err) {
 66 |           return reject(err)
 67 |         }
 68 |         resolve(template)
 69 |       })
 70 |   })
 71 | }
 72 | 
 73 | const getTemplate = (id) => {
 74 |   return new Promise((resolve, reject) => {
 75 |     templateModel.findOne({ _id: mongoose.Types.ObjectId(id) }).exec((err, template) => {
 76 |       if (err) {
 77 |         return reject(err)
 78 |       }
 79 |       resolve(template)
 80 |     })
 81 |   })
 82 | }
 83 | 
 84 | const getTemplateCount = () => {
 85 |   return new Promise((resolve, reject) => {
 86 |     templateModel.countDocuments((err, count) => {
 87 |       if (err) {
 88 |         return reject(err)
 89 |       }
 90 |       // console.log(count)
 91 |       resolve(count)
 92 |     })
 93 |   })
 94 | }
 95 | 
 96 | const createTemplate = (data) => {
 97 |   return new Promise((resolve, reject) => {
 98 |     templateModel.create(
 99 |       { ...data, _id: mongoose.Types.ObjectId() },
100 |       (err, template) => {
101 |         if (err) {
102 |           return reject(err)
103 |         }
104 |         resolve(template)
105 |       }
106 |     )
107 |   })
108 | }
109 | 
110 | const addLike = (id) => {
111 |   return new Promise((resolve, reject) => {
112 |     templateModel.findOneAndUpdate({ _id: id }, { $inc: { likes: 1 } }, (err, template) => {
113 |       if (err) {
114 |         return reject(err)
115 |       }
116 |       resolve(template.likes)
117 |     })
118 |   })
119 | }
120 | 
121 | const createEmail = (templateId, user, emails, subject) => {
122 |   return new Promise((resolve, reject) => {
123 |     const recipients = emails.map(recipient => ({ email: recipient, read: false }))
124 |     emailModel.create(
125 |       { template: templateId, recipients, user, subject, _id: mongoose.Types.ObjectId() },
126 |       (err, email) => {
127 |         if (err) {
128 |           return reject(err)
129 |         }
130 |         resolve(email)
131 |       }
132 |     )
133 |   })
134 | }
135 | 
136 | const getEmailsByUser = (email) => {
137 |   return new Promise((resolve, reject) => {
138 |     emailModel.find({ user: email }).populate('template').exec((err, emails) => {
139 |       if (err) {
140 |         return reject(err)
141 |       }
142 |       resolve(emails)
143 |     })
144 |   })
145 | }
146 | 
147 | const getEmailById = (id) => {
148 |   return new Promise((resolve, reject) => {
149 |     emailModel.findOne({ _id: id }).populate('template').exec((err, email) => {
150 |       if (err) {
151 |         return reject(err)
152 |       }
153 |       resolve(email)
154 |     })
155 |   })
156 | }
157 | 
158 | const addEmailRead = (id, email) => {
159 |   return new Promise((resolve, reject) => {
160 |     getEmailById(id).then((result) => {
161 |       const user = result.recipients.filter(recipient => recipient.email === email)
162 |       const otherUsers = result.recipients.filter(recipient => recipient.email !== email)
163 |       user[0].read = true
164 |       user[0].readTime = Date.now()
165 |       result.recipients = [...otherUsers, user[0]]
166 |       emailModel.updateOne({ _id: id }, result).exec((err, email) => {
167 |         if (err) { return reject(err) }
168 |         return resolve(email)
169 |       })
170 |     })
171 |   })
172 | }
173 | 
174 | const getFileByUserId = (id) => {
175 |   return new Promise((resolve, reject) => {
176 |     fileModel.find({ userId: id }).exec((err, files) => {
177 |       if (err) { return reject(err) }
178 |       resolve(files)
179 |     })
180 |   })
181 | }
182 | 
183 | const addFiles = async (userId, files) => {
184 |   await Promise.all(files.map(file => (fileHandler.uploadFile(file.path, userId))))
185 |   await fileModel.insertMany(files.map(file => ({
186 |     size: file.size,
187 |     name: file.originalname,
188 |     user: userId,
189 |     path: `${userId}/${file.path.split('/').pop().replace(' ', '+')}`,
190 |     mimeType: file.mimeType
191 |   })))
192 |   Promise.all(files.map(file => fileHandler.unlinkFile(file.path.split('/').pop())))
193 |   return new Promise((resolve, reject) => {
194 |     fileModel.find({ user: userId }).then(resolve).catch(reject)
195 |   })
196 | }
197 | const getTotalEmailStats = () => {
198 |   return new Promise((resolve, reject) => {
199 |     emailModel.aggregate([
200 |       {
201 |         $unwind: {
202 |           path: '$recipients'
203 |         }
204 |       },
205 |       {
206 |         $count: 'totalCount'
207 |       }
208 |     ]).exec().then((result) => {
209 |       resolve(result)
210 |     }).catch(reject)
211 |   })
212 | }
213 | 
214 | const getReadEmailStats = () => {
215 |   return new Promise((resolve, reject) => {
216 |     emailModel.aggregate([
217 |       {
218 |         $unwind: {
219 |           path: '$recipients'
220 |         }
221 |       },
222 |       {
223 |         $match: {
224 |           'recipients.read': true
225 |         }
226 |       },
227 |       {
228 |         $count: 'readCount'
229 |       }
230 |     ]).exec().then((result) => {
231 |       resolve(result)
232 |     }).catch(reject)
233 |   })
234 | }
235 | 
236 | module.exports = {
237 |   getUserData,
238 |   createUser,
239 |   getTemplates,
240 |   getTemplate,
241 |   getUserDataById,
242 |   getTemplateCount,
243 |   createTemplate,
244 |   addLike,
245 |   createEmail,
246 |   getEmailsByUser,
247 |   getEmailById,
248 |   getFileByUserId,
249 |   addFiles,
250 |   addEmailRead,
251 |   getTotalEmailStats,
252 |   getReadEmailStats
253 | }
254 | 


--------------------------------------------------------------------------------