feat: implement submissions management with global state and API integration

Author: IgorShadurin

backend/src/index.ts

@@ -11,6 +11,7 @@ import { createFeedbackRouter } from './routes/feedback'
 import { createNotificationService } from './services/notification'
 import cors from 'cors'
 import path from 'path'
+import { createSystemRouter } from './routes/system'
 
 // Determine if we're running from dist or directly from src
 const isDist = __dirname.includes('dist')
@@ -59,6 +60,7 @@ app.use('/api/templates', createTemplatesRouter(db, notificationService))
 app.use('/api/ai', createAiRouter(db))
 app.use('/api/telegram', createTelegramRouter(db))
 app.use('/api/feedback', createFeedbackRouter(db, notificationService))
+app.use('/api/system', createSystemRouter())
 
 const port = process.env.PORT || 3001
 app.listen(port, () => {

backend/src/routes/apps.ts

@@ -8,6 +8,7 @@ import { JsonSchema, validateInputData } from '../utils/input-validation'
 import { validateJson, JsonValidationError } from '../utils/jsonValidation'
 import { INotificationService } from '../services/notification'
 import { truncateText } from '../utils/text'
+import { globalState } from '../utils/globalState'
 
 /**
  * Extended Request type that includes the authenticated wallet address
@@ -56,6 +57,13 @@ export function createAppsRouter(db: Knex, notificationService: INotificationSer
   // Create new app
   router.post('/my-apps', requireAuth, (async (req: Request, res: Response) => {
     try {
+      // Check if submissions are enabled
+      if (!globalState.getSubmissionsEnabled()) {
+        return res.status(403).json({
+          error: 'Submissions are currently disabled. Thank you for your participation in the hackathon!',
+        })
+      }
+
       const body = req.body
       if (!body || typeof body !== 'object') {
         return res.status(400).json({ error: 'Invalid request body' })

backend/src/routes/system.ts

@@ -0,0 +1,26 @@
+import { Router, Request, Response } from 'express'
+import { globalState } from '../utils/globalState'
+
+/**
+ * Creates and configures the system router
+ * @returns {Router} Express router configured with system routes
+ */
+export function createSystemRouter(): Router {
+  const router = Router()
+
+  // Get current submissions status
+  router.get('/submissions-status', (req: Request, res: Response) => {
+    try {
+      const areSubmissionsEnabled = globalState.getSubmissionsEnabled()
+      res.json({
+        areSubmissionsEnabled,
+        message: areSubmissionsEnabled ? 'Submissions are currently enabled' : 'Submissions are currently disabled',
+      })
+    } catch (error) {
+      console.error('Error getting submissions status:', error)
+      res.status(500).json({ error: 'Internal server error' })
+    }
+  })
+
+  return router
+}

backend/src/routes/telegram.ts

@@ -2,6 +2,7 @@ import { Router, Request, Response, RequestHandler } from 'express'
 import { Knex } from 'knex'
 import * as dotenv from 'dotenv'
 import path from 'path'
+import { globalState } from '../utils/globalState'
 
 // Type definition for telegram update
 interface TelegramUpdate {
@@ -220,6 +221,33 @@ export function createTelegramRouter(db: Knex): Router {
         }
       }
 
+      // Command for controlling submissions
+      if (lowerCaseMessage.startsWith('submissions:')) {
+        const submissionsValue = message.substring('submissions:'.length).trim()
+
+        if (submissionsValue === '1') {
+          globalState.setSubmissionsEnabled(true)
+          return res.status(200).json({
+            method: 'sendMessage',
+            chat_id: chatId,
+            text: 'Submissions have been enabled.',
+          })
+        } else if (submissionsValue === '0') {
+          globalState.setSubmissionsEnabled(false)
+          return res.status(200).json({
+            method: 'sendMessage',
+            chat_id: chatId,
+            text: 'Submissions have been disabled.',
+          })
+        } else {
+          return res.status(200).json({
+            method: 'sendMessage',
+            chat_id: chatId,
+            text: 'Invalid submissions value. Use "submissions: 1" to enable or "submissions: 0" to disable.',
+          })
+        }
+      }
+
       // If none of the commands matched, send help message
       return res.status(200).json({
         method: 'sendMessage',
@@ -229,9 +257,11 @@ export function createTelegramRouter(db: Knex): Router {
           '- "public apps: 1, 2, 3" or "public apps: 1-10" - Make specified apps public\n' +
           '- "public templates: 1, 2, 3" or "public templates: 1-10" - Make specified templates public\n' +
           '- "private apps: 1, 2, 3" or "private apps: 1-10" - Make specified apps private\n' +
-          '- "private templates: 1, 2, 3" or "private templates: 1-10" - Make specified templates private',
+          '- "private templates: 1, 2, 3" or "private templates: 1-10" - Make specified templates private\n' +
+          '- "submissions: 1" - Enable submissions\n' +
+          '- "submissions: 0" - Disable submissions',
       })
-    } catch (error) {
+    } catch (error: unknown) {
       console.error('Error processing telegram webhook:', error)
       res.sendStatus(200) // Always respond with 200 to Telegram
     }

backend/src/routes/templates.ts

@@ -5,6 +5,7 @@ import { validateTemplate, ValidationError } from '../utils/templateValidation'
 import { Template, CreateTemplateDTO } from '../types/template'
 import { INotificationService } from '../services/notification'
 import { truncateText } from '../utils/text'
+import { globalState } from '../utils/globalState'
 
 /**
  * Extended request interface for template creation
@@ -49,6 +50,13 @@ export function createTemplatesRouter(db: Knex, notificationService: INotificati
   // Create template
   router.post('/', requireAuth, async (req: CreateTemplateRequest, res: Response) => {
     try {
+      // Check if submissions are enabled
+      if (!globalState.getSubmissionsEnabled()) {
+        return res.status(403).json({
+          error: 'Submissions are currently disabled. Thank you for your participation in the hackathon!',
+        })
+      }
+
       const { address, signature } = req.body
       const templateData: CreateTemplateDTO = {
         title: req.body.title,

backend/src/tests/apps.test.ts

@@ -6,6 +6,7 @@ import { type PrivateKeyAccount } from 'viem/accounts'
 import { createWalletClient } from 'viem'
 import { TestDb } from './utils/testDb'
 import { MockNotificationService } from './__mocks__/notification'
+import { globalState } from '../utils/globalState'
 
 const quizSchema = {
   type: 'object',
@@ -400,6 +401,39 @@ describe('Apps API', () => {
         expect(response.status).toBe(400)
         expect(response.body.error).toBe('Missing required fields')
       })
+
+      it('should reject app creation when submissions are disabled', async () => {
+        // Disable submissions
+        globalState.setSubmissionsEnabled(false)
+
+        const name = 'Test App'
+        const message = `Create app: ${name}`
+        const signature = await walletClient.signMessage({
+          message,
+          account: testAccount,
+        })
+
+        const response = await request(expressApp)
+          .post('/api/my-apps')
+          .set('x-wallet-address', testAccount.address)
+          .send({
+            name: name,
+            description: 'Test Description',
+            signature,
+            template_id: templateId,
+            json_data: quizData,
+          })
+
+        expect(response.status).toBe(403)
+        expect(response.body.error).toBe('Submissions are currently disabled. Thank you for your participation in the hackathon!')
+
+        // Verify no app was created
+        const apps = await db('apps').where('owner_address', testAccount.address)
+        expect(apps).toHaveLength(0)
+
+        // Re-enable submissions for other tests
+        globalState.setSubmissionsEnabled(true)
+      })
     })
   })
 

backend/src/tests/system.test.ts

@@ -0,0 +1,43 @@
+import request from 'supertest'
+import express from 'express'
+import { createSystemRouter } from '../routes/system'
+import { globalState } from '../utils/globalState'
+
+describe('System API', () => {
+  let app: express.Express
+
+  beforeEach(() => {
+    app = express()
+    app.use(express.json())
+    app.use('/', createSystemRouter())
+
+    // Reset global state to default
+    globalState.setSubmissionsEnabled(true)
+  })
+
+  describe('GET /submissions-status', () => {
+    it('should return submissions enabled status', async () => {
+      globalState.setSubmissionsEnabled(true)
+
+      const response = await request(app).get('/submissions-status')
+
+      expect(response.status).toBe(200)
+      expect(response.body).toEqual({
+        areSubmissionsEnabled: true,
+        message: 'Submissions are currently enabled',
+      })
+    })
+
+    it('should return submissions disabled status', async () => {
+      globalState.setSubmissionsEnabled(false)
+
+      const response = await request(app).get('/submissions-status')
+
+      expect(response.status).toBe(200)
+      expect(response.body).toEqual({
+        areSubmissionsEnabled: false,
+        message: 'Submissions are currently disabled',
+      })
+    })
+  })
+})

backend/src/tests/telegram.test.ts

@@ -2,6 +2,7 @@ import request from 'supertest'
 import express from 'express'
 import { Knex } from 'knex'
 import { createTelegramRouter } from '../routes/telegram'
+import { globalState } from '../utils/globalState'
 
 // Mock environment variables
 process.env.TELEGRAM_CHAT_ID = '123456789'
@@ -229,6 +230,8 @@ describe('Telegram Webhook', () => {
         chat_id: 123456789,
         text: expect.stringContaining('Supported commands:'),
       })
+      expect(response.body.text).toContain('submissions: 1')
+      expect(response.body.text).toContain('submissions: 0')
       expect(mockDb).not.toHaveBeenCalled()
     })
 
@@ -463,6 +466,100 @@ describe('Telegram Webhook', () => {
       })
       expect(mockDb).not.toHaveBeenCalled()
     })
+
+    it('should process submissions enable command correctly', async () => {
+      const response = await request(app)
+        .post('/webhook')
+        .send({
+          update_id: 123456789,
+          message: {
+            message_id: 1,
+            from: {
+              id: 123456789,
+              is_bot: false,
+              first_name: 'Test',
+            },
+            chat: {
+              id: 123456789, // Same as TELEGRAM_CHAT_ID
+              first_name: 'Test',
+              type: 'private',
+            },
+            date: 1631234567,
+            text: 'submissions: 1',
+          },
+        })
+
+      expect(response.status).toBe(200)
+      expect(response.body).toEqual({
+        method: 'sendMessage',
+        chat_id: 123456789,
+        text: 'Submissions have been enabled.',
+      })
+
+      expect(globalState.getSubmissionsEnabled()).toBe(true)
+    })
+
+    it('should process submissions disable command correctly', async () => {
+      const response = await request(app)
+        .post('/webhook')
+        .send({
+          update_id: 123456789,
+          message: {
+            message_id: 1,
+            from: {
+              id: 123456789,
+              is_bot: false,
+              first_name: 'Test',
+            },
+            chat: {
+              id: 123456789,
+              first_name: 'Test',
+              type: 'private',
+            },
+            date: 1631234567,
+            text: 'submissions: 0',
+          },
+        })
+
+      expect(response.status).toBe(200)
+      expect(response.body).toEqual({
+        method: 'sendMessage',
+        chat_id: 123456789,
+        text: 'Submissions have been disabled.',
+      })
+
+      expect(globalState.getSubmissionsEnabled()).toBe(false)
+    })
+
+    it('should handle invalid submissions command correctly', async () => {
+      const response = await request(app)
+        .post('/webhook')
+        .send({
+          update_id: 123456789,
+          message: {
+            message_id: 1,
+            from: {
+              id: 123456789,
+              is_bot: false,
+              first_name: 'Test',
+            },
+            chat: {
+              id: 123456789,
+              first_name: 'Test',
+              type: 'private',
+            },
+            date: 1631234567,
+            text: 'submissions: invalid',
+          },
+        })
+
+      expect(response.status).toBe(200)
+      expect(response.body).toEqual({
+        method: 'sendMessage',
+        chat_id: 123456789,
+        text: 'Invalid submissions value. Use "submissions: 1" to enable or "submissions: 0" to disable.',
+      })
+    })
   })
 })
 /* eslint-enable @typescript-eslint/unbound-method */

backend/src/tests/templates.test.ts

@@ -9,6 +9,7 @@ import { TestDb } from './utils/testDb'
 import { Router } from 'express'
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 import { MockNotificationService } from './__mocks__/notification'
+import { globalState } from '../utils/globalState'
 
 interface DbTemplate {
   id: number
@@ -201,6 +202,38 @@ describe('Templates API', () => {
       expect(response.body.error).toBe(TEMPLATE_VALIDATION.JSON_TOO_LONG)
     }, 30000)
 
+    it('should reject template creation when submissions are disabled', async () => {
+      // Disable submissions
+      globalState.setSubmissionsEnabled(false)
+
+      const message = `Create template: ${validTemplate.title}`
+      const signature = await walletClient.signMessage({
+        message,
+        account: testAccount,
+      })
+
+      const response = await request(expressApp)
+        .post('/api/templates')
+        .set('x-wallet-address', testAccount.address)
+        .send({
+          ...validTemplate,
+          address: testAccount.address,
+          signature,
+        })
+
+      expect(response.status).toBe(403)
+      expect(response.body.error).toBe('Submissions are currently disabled. Thank you for your participation in the hackathon!')
+
+      // Verify no template was created
+      const templates = await db<DbTemplate>('templates')
+        .whereRaw('LOWER(owner_address) = ?', [testAccount.address.toLowerCase()])
+        .select()
+      expect(templates).toHaveLength(0)
+
+      // Re-enable submissions for other tests
+      globalState.setSubmissionsEnabled(true)
+    }, 30000)
+
     it('should handle errors gracefully', async () => {
       // Silence console.error during this test
       console.error = jest.fn()