chore: add code

Author: Viiprogrammer

locales/ru.js

@@ -0,0 +1,39 @@
+module.exports = {
+  translation: {
+    keyboard: {
+      main: {},
+      back: '◀️ Назад'
+    },
+    src: {
+      originTooLong: 'Увы, оригинальное сообщение слишком длинное'
+    },
+    getId: {
+      text: '<b>Тип идентификатора:</b> <code>{{ type }}</code>{{- anonymous }}\n' + // "-" disables escape for variable
+        '<b>Идентификатор:</b> <code>{{ id }}</code>',
+      anonymous: '(анонимный администратор <code>{{ name }}</code>)',
+      inlineTitle: 'Ваш ID {{ id }}',
+      inlineDescription: 'Нажмите, чтобы отправит его в текущий чат',
+      inlineContent: 'Мой Telegram ID {{ id }}'
+    },
+    reference: {
+      openButton: '🔗 Bots API Reference',
+      botsApiTitle: 'Telegram Bot API Reference {{ version }} ({{ date }})',
+      botsApiDescription: 'The Bot API is an HTTP-based interface created for developers keen on building bots for Telegram.',
+      botsApiContent: '<a href="https://core.telegram.org/bots/api">Telegram Bot API Reference</a>',
+      methodContent: '*Method:* `{{ name }}`:\n\n' +
+        '{{- description }}\n' +
+        '*Arguments:*\n' +
+        '{{- arguments }}',
+      typeContent: '*Type:* `{{ name }}`:\n\n' +
+        '{{- description }}\n\n' +
+        '*Properties:*\n' +
+        '{{- properties }}',
+      opengramTitle: 'Opengram API Reference',
+      opengramDescription: 'Нажмите для отправки в текущий чат',
+      opengramContent: '<a href="https://reference.opengram.dev">Opengram API Reference</a>'
+    },
+    unmatched: {
+      message: '<b>Главное меню</b>'
+    }
+  }
+}

src/components/user/user.model.js

@@ -0,0 +1,53 @@
+const { Schema, model } = require('mongoose')
+
+const user = new Schema({
+  user: {
+    name: {
+      type: String,
+      required: false
+    },
+    nameLower: {
+      type: String,
+      required: false
+    },
+    first: {
+      type: String,
+      required: true
+    },
+    last: {
+      type: String,
+      required: false
+    }
+  },
+  userId: {
+    type: Number,
+    required: true,
+    index: {
+      unique: true
+    }
+  }
+}, {
+  timestamps: true,
+  autoCreate: true,
+  autoIndex: true
+})
+
+user.index({ 'user.name': 1 }, {
+  unique: true,
+  partialFilterExpression: {
+    'user.name': {
+      $exists: true
+    }
+  }
+})
+
+user.index({ 'user.nameLower': 1 }, {
+  unique: true,
+  partialFilterExpression: {
+    'user.name': {
+      $exists: true
+    }
+  }
+})
+
+module.exports = { User: model('user', user) }

src/config.js

@@ -0,0 +1,7 @@
+const { BOT_TOKEN, MONGODB_URI } = process.env
+
+module.exports = {
+  BOT_TOKEN,
+  MONGODB_URI,
+  isProduction: process.env.NODE_ENV && process.env.NODE_ENV !== 'development'
+}

src/index.js

@@ -0,0 +1,3 @@
+require('dotenv').config()
+require('./lib/database')
+require('./lib/bot')()

src/keyboards/index.js

@@ -0,0 +1,5 @@
+const { mainKeyboard } = require('./main.keyboard')
+
+module.exports = {
+  mainKeyboard
+}

src/keyboards/main.keyboard.js

@@ -0,0 +1,13 @@
+const { Extra, Markup } = require('opengram')
+
+const mainKeyboard = function createMainKeyboard (ctx) {
+  return Extra.markup(m => {
+    return m.keyboard([
+      Markup.button(ctx.i18n.t('keyboard.main.createStickers')),
+      Markup.button(ctx.i18n.t('keyboard.main.back'))
+    ], { columns: 1 })
+      .resize()
+  })
+}
+
+module.exports = { mainKeyboard }

src/lib/bot.js

@@ -0,0 +1,87 @@
+const { Opengram, session } = require('opengram')
+const { MediaGroup } = require('@opengram/media-group')
+const { BOT_TOKEN } = require('../config')
+const { handlers } = require('../middlewares/handlers')
+const { logger } = require('./logger')
+const { stage } = require('../middlewares/stage')
+const { authorization } = require('../middlewares/authorization')
+const { StickerSet, User } = require('./models')
+const { i18nFactory } = require('../middlewares/i18n')
+const i18next = require('i18next')
+const fetch = require('node-fetch')
+const { sha1 } = require('./utils')
+
+const bot = new Opengram(BOT_TOKEN)
+
+bot.context.model = {
+  User,
+  StickerSet
+}
+
+async function startBot () {
+  bot.context.loadBotsAPIReference = async function () {
+    const data = await fetch('https://ark0f.github.io/tg-bot-api/custom.json')
+      .then(x => x.json())
+
+    data.objects.forEach((v, i) => {
+      data.objects[i].__object = true
+      data.objects[i].id = sha1([v.name, 'type'].join())
+    })
+
+    data.methods.forEach((v, i) => {
+      data.methods[i].__method = true
+      data.methods[i].id = sha1([v.name, 'method'].join())
+    })
+
+    bot.context.botsAPIReference = data
+  }
+
+  await bot.context.loadBotsAPIReference()
+
+  await i18next.init({
+    lng: 'ru',
+    fallbackLng: 'ru',
+    debug: true,
+    resources: {
+      ru: require('../../locales/ru')
+    }
+  })
+
+  bot.use(
+    new MediaGroup(),
+    session({
+      /**
+       * Session key generator
+       *
+       * @param {OpengramContext} ctx Context
+       * @return {null|string}
+       */
+      getSessionKey: (ctx) => {
+        if (ctx.from.id && ctx.chat?.id) {
+          return `${ctx.from.id}:${ctx.chat.id}`
+        }
+
+        if (ctx.inlineQuery || ctx.callbackQuery?.inline_message_id) {
+          return `${ctx.from.id}:${ctx.from.id}`
+        }
+
+        return null
+      }
+    }),
+    i18nFactory(i18next),
+    authorization,
+    stage,
+    handlers
+  )
+
+  bot.catch(err => logger.error('Bot error:', err))
+
+  return bot.launch({
+    polling: {
+      allowedUpdates: ['callback_query', 'message', 'inline_query']
+    }
+  })
+    .then(() => logger.info('Bot started successfully'))
+}
+
+module.exports = startBot

src/lib/database.js

@@ -0,0 +1,15 @@
+const mongoose = require('mongoose')
+const { logger } = require('./logger')
+const { MONGODB_URI } = require('../config')
+
+mongoose.connection
+  .on('open', () => logger.info('Database connection: open'))
+  .on('close', () => logger.info('Database connection: close'))
+  .on('disconnected', () => logger.warn('Database connection: disconnecting'))
+  .on('reconnectFailed', () => logger.error('Database connection: reconnect failed'))
+  .on('reconnected', () => logger.info('Database connection: reconnected'))
+  .on('fullsetup', () => logger.info('Database connection: fullsetup'))
+  .on('all', () => logger.info('Database connection: all'))
+  .on('error', error => logger.error('MongoDB connection: error', error))
+
+mongoose.connect(MONGODB_URI)

src/lib/logger.js

@@ -0,0 +1,36 @@
+const winston = require('winston')
+const { format, transports } = require('winston')
+const { isProduction } = require('../config')
+
+const logger = winston.createLogger({ level: 'info' })
+
+if (!isProduction) {
+  logger.add(
+    new transports.Console({
+      format: format.combine(
+        format.errors({ stack: true }),
+        format.colorize({ all: true }),
+        format.label({ label: '[LOGGER]' }),
+        format.timestamp({ format: 'YY-MM-DD HH:MM:SS' }),
+        format.prettyPrint(),
+        winston.format.printf(
+          ({ level, message, label, timestamp, stack }) => {
+            return ` ${label} ${timestamp} [${level}]: ${message}` + (stack ? '\n' + stack : '')
+          }
+        )
+      )
+    })
+  )
+} else {
+  logger.add(
+    new transports.File({
+      filename: 'error.log',
+      level: 'error'
+    })
+  )
+  logger.add(
+    new transports.File({ filename: 'combined.log' })
+  )
+}
+
+module.exports = { logger }

src/lib/models.js

@@ -0,0 +1,3 @@
+const { User } = require('../components/user/user.model')
+
+module.exports = { User }

src/lib/resolveBotsAPIReferenceType.js

@@ -0,0 +1,56 @@
+class T {
+  constructor () {
+    this.types = {
+      undefined: '*',
+      properties: 'object',
+      any_of: 'any_of',
+      string: 'string',
+      integer: 'number',
+      reference: 'reference',
+      bool: 'boolean',
+      array: 'Array',
+      float: 'number'
+    }
+
+    this.references = new Set()
+  }
+
+  enumerate (data) {
+    const { enumeration, type } = data
+    if (enumeration === undefined) return type
+
+    return enumeration.map(x => `'${x}'`)
+      .join('|')
+  }
+
+  resolveArrayType ({ array }) {
+    return `${
+      this.getType(array)
+    }[]`
+  }
+
+  getType (data) {
+    const {
+      type,
+      reference
+    } = data
+
+    const resType = this.types[type]
+
+    if (resType === 'any_of') {
+      return data.any_of.map(x => this.getType(x))
+        .join('|')
+    }
+
+    if (type === 'array') return this.resolveArrayType(data)
+    if (type === 'string') return this.enumerate(data)
+
+    if (resType === 'reference') {
+      this.references.add(reference)
+    }
+
+    return resType === 'reference' ? reference : resType
+  }
+}
+
+module.exports = { T }