snapio-mock-camera 1.0.0

package/_index.js

@@ -0,0 +1,110 @@
+const express = require('express');
+const cors = require('cors');
+const path = require('path');
+const app = express();
+const fs = require('fs');
+const { Observable, Subject } = require('rxjs');
+const { take } = require('rxjs/operators')
+const { createCanvas, loadImage } = require('canvas');
+const octopus = require('./octopus')
+const printer = require('./printer')
+
+app.use(cors());
+
+let takeImage = {};
+
+const IMAGE_SRC = 'public/960x640.jpg';
+
+app.get('/liveViewImage', (req, res) => {
+  let s = fs.createReadStream(IMAGE_SRC);
+  s.on('open', function () {
+    res.set('Content-Type', 'image/jpeg');
+    s.pipe(res);
+  });
+  s.on('error', function () {
+    res.set('Content-Type', 'text/plain');
+    res.status(404).end('Not found');
+  });
+});
+app.get('/image', (req, res) => {
+  setTimeout(() => {
+    const latest = Math.max.apply(Math, Object.keys(takeImage));
+    if (!takeImage[latest]) return;
+    const { width, height, $ } = takeImage[latest];
+    const canvas = createCanvas(width, height)
+    const ctx = canvas.getContext('2d');
+    $.pipe(
+      take(1)
+    ).subscribe(value => {
+      console.log(new Date().toISOString(), 'image taken');
+      loadImage(IMAGE_SRC).then(img => {
+        const nRatio = img.naturalWidth / img.naturalHeight;
+        const sRatio = width / height;
+        if (nRatio < sRatio) {
+          const scale = width / img.naturalWidth;
+          ctx.drawImage(img,
+            0, (img.naturalHeight - height / scale) / 2, img.naturalWidth, height / scale,
+            0, 0, width, height);
+        } else {
+          const scale = height / img.naturalHeight;
+          ctx.drawImage(img,
+            (img.naturalWidth - width / scale) / 2, 0, width / scale, img.naturalHeight,
+            0, 0, width, height);
+        }
+        res.set('Content-Type', 'image/jpeg');
+        canvas.createJPEGStream().pipe(res)
+      })
+      delete takeImage[latest];
+    })
+  }, 200)
+});
+app.post('/startLiveView', (req, res) => {
+  res.status(200).end();
+})
+app.post('/stopLiveView', (req, res) => {
+  res.status(200).end();
+})
+app.post('/shoot', (req, res) => {
+  const latest = Math.max.apply(Math, Object.keys(takeImage));
+  if (takeImage[latest])
+    takeImage[latest].$.next(true);
+  res.status(200).end();
+})
+app.post('/createTimer', (req, res) => {
+  const params = req.query;
+  const { width, height, seconds } = params;
+  const intSeconds = seconds ? parseInt(seconds) : 0;
+  console.log(new Date().toISOString(), `${intSeconds} secs`);
+  const now = new Date().getTime();
+  takeImage[now] = {
+    width: parseInt(width),
+    height: parseInt(height),
+    $: new Subject()
+  };
+  if (intSeconds > 0) {
+    const timeout = setTimeout(_ => {
+      console.log(new Date().toISOString(), 'timeout');
+      if (takeImage[now])
+        takeImage[now].$.next(true);
+    }, intSeconds * 1000);
+  }
+  res.status(200).end();
+})
+app.post('/setProperty', (req, res) => {
+  res.status(200).end();
+})
+app.get('/health', (req, res) => {
+  res.setHeader('content-type', 'application/json')
+  res.send({
+    status: 'pass',
+    details: {
+      isSDKLoaded: true,
+      isSessionOpen: true,
+    },
+    version: '999.9'
+  })
+})
+
+app.listen(40084, function () {
+  console.log('Camera listening on http://localhost:40084/');
+});

package/camera.js

@@ -0,0 +1,364 @@
+// Import necessary modules
+const express = require('express');
+const cors = require('cors');
+const { spawn } = require('child_process'); // To run external commands like ffmpeg
+const http = require('http'); // Required for HTTP server
+const { Observable, Subject, BehaviorSubject } = require('rxjs');
+const { take, takeUntil, filter, switchMap, first, throttleTime, takeWhile } = require('rxjs/operators')
+const { createCanvas, loadImage } = require('canvas');
+
+// Initialize Express application
+const app = express();
+app.use(cors())
+const port = process.env['SNAPIO_CAMERA_MANAGER_PORT'] ? Number(process.env['SNAPIO_CAMERA_MANAGER_PORT']) : 40084;
+
+// Create an HTTP server and attach Express app
+const server = http.createServer(app);
+
+let ffmpegProcess = null; // Variable to hold the ffmpeg process
+let liveView = new BehaviorSubject(null);
+let takeImage = {};
+// --- MJPEG Stream Endpoint ---
+app.get('/liveViewImage', (req, res) => {
+    console.log('Client connected to /liveViewImage endpoint (multipart/x-mixed-replace).');
+    const close$ = new Subject()
+    let isHeadersSent = false;
+    liveView.pipe(
+      throttleTime(1000/8),
+      filter(data => data != null),
+      takeUntil(close$)
+    ).subscribe({
+      next: (data) => {
+        if (!isHeadersSent) {
+          res.writeHead(200, {
+              'Content-Type': 'multipart/x-mixed-replace; boundary=--myboundary',
+              'Cache-Control': 'no-cache',
+              'Connection': 'keep-alive',
+          });
+          isHeadersSent = true
+        }
+        res.write('--myboundary\r\n');
+        res.write('Content-Type: image/jpeg\r\n');
+        res.write('Content-Length: ' + data.length + '\r\n');
+        res.write('\r\n');
+        res.write(data); // Send raw MJPEG frame data
+        res.write('\r\n');
+      },
+      error: (err) => {
+        console.log(`Live view subscription error: ${ err }`)
+        res.status(500).send(`Error in ffmpeg process: ${ err }`)
+        res.end()
+        ffmpegProcess?.kill('SIGKILL')
+        ffmpegProcess = null;
+      },
+      complete: () => {
+        console.log('Live view subscription complete')
+        res.end('--myboundary--\r\n'); // End the multipart stream gracefully
+      }
+    })
+    // Handle client disconnection from the HTTP stream
+    req.on('close', () => {
+        console.log('Client disconnected from /liveViewImage. Killing ffmpeg process.');
+        close$.next()
+    });
+
+    req.on('error', (err) => {
+        console.error('Request error on /liveViewImage:', err);
+        close$.next()
+    });
+});
+app.get('/image', (req, res) => {
+  setTimeout(() => {
+    const latest = Math.max.apply(Math, Object.keys(takeImage));
+    if (!takeImage[latest]) return;
+    const { width, height, $ } = takeImage[latest];
+    const canvas = createCanvas(width, height)
+    const ctx = canvas.getContext('2d');
+    $.pipe(
+      take(1),
+      switchMap(() => liveView.pipe(
+        takeWhile(data => data != null)
+      )),
+    ).subscribe(async data => {
+      console.log(new Date().toISOString(), 'image taken');
+      const { w, h } = jpegProps(data);
+      const nRatio = w / h;
+      const sRatio = width / height;
+      const img = await loadImage(data)
+      if (nRatio < sRatio) {
+        const scale = width / w;
+        ctx.drawImage(img,
+          0, (h - height / scale) / 2, w, height / scale,
+          0, 0, width, height);
+      } else {
+        const scale = height / h;
+        ctx.drawImage(img,
+          (w - width / scale) / 2, 0, width / scale, h,
+          0, 0, width, height);
+      }
+      res.set('Content-Type', 'image/jpeg');
+      canvas.createJPEGStream().pipe(res)
+      delete takeImage[latest];
+    })
+  }, 200)
+})
+app.post('/shoot', (req, res) => {
+  const latest = Math.max.apply(Math, Object.keys(takeImage));
+  if (takeImage[latest])
+    takeImage[latest].$.next(true);
+  res.status(200).end();
+})
+app.post('/createTimer', (req, res) => {
+  const params = req.query;
+  const { width, height, seconds } = params;
+  const intSeconds = seconds ? parseInt(seconds) : 0;
+  console.log(new Date().toISOString(), `${intSeconds} secs`);
+  const now = new Date().getTime();
+  takeImage[now] = {
+    width: parseInt(width),
+    height: parseInt(height),
+    $: new Subject()
+  };
+  if (intSeconds > 0) {
+    const timeout = setTimeout(_ => {
+      console.log(new Date().toISOString(), 'timeout');
+      if (takeImage[now])
+        takeImage[now].$.next(true);
+    }, intSeconds * 1000);
+  }
+  res.status(200).end();
+})
+
+app.post('/startLiveView', (req, res) => {
+  if (ffmpegProcess) {
+    console.log('ffmpeg is already running')
+    res.status(200).end();
+    return;
+  }
+  try {
+      liveView = new BehaviorSubject(null);
+      if (process.platform == 'darwin') {
+        // ffmpeg -y -f avfoundation -r 8 -i 0 -s 960x540 -f mjpeg -
+        // ffmpegProcess = spawn('ffmpeg', [
+        //   '-y', '-f', 'avfoundation', '-r', '8', '-i', '0', '-s', '960x540', '-f', 'mjpeg', '-'
+        // ]);
+        // ffmpeg -y -f avfoundation -r 7.5 -i 0 -s 1280x720 -f mjpeg -
+        ffmpegProcess = spawn('ffmpeg', [
+          '-y', '-f', 'avfoundation', '-r', '15', '-i', '0', '-s', '960x720', '-f', 'mjpeg', '-'
+        ]);
+      } else if (process.platform == 'win32') {
+        ffmpegProcess = spawn('ffmpeg', [
+            '-y',
+            '-f', 'vfwcap',
+            '-i', '0',
+            // '-q:v', '3',         // Video quality (lower is better, 1-31)
+            '-r', '8',          // Frame rate (frames per second)
+            // '-s', '640x480',     // Resolution
+            '-f', 'mjpeg',
+            '-'                  // Output to stdout
+        ]);
+      } else {
+        throw new Error('Unsupported platform: ' + process.platform);
+      }
+      ffmpegProcess.stdout.on('data', data => {
+          liveView.next(data);
+      });
+      // Handle ffmpeg process errors
+      ffmpegProcess.stderr.on('data', data => {
+        // the standard output always comes out from here, ignore
+        // console.error(`ffmpeg stderr: ${data}`);
+        // liveView.error(data)
+        // liveView.complete()
+      });
+      // Handle ffmpeg process close
+      ffmpegProcess.on('close', code => {
+          console.log(`ffmpeg process exited with code ${code}. Closing stream.`);
+          liveView.complete()
+          ffmpegProcess = null; // Clear the process reference
+      });
+      // Handle ffmpeg process errors (e.g., ffmpeg not found)
+      ffmpegProcess.on('error', err => {
+          console.error('Failed to start ffmpeg process:', err);
+          liveView.error(err)
+          liveView.complete()
+          ffmpegProcess = null;
+      });
+      res.status(200).end();
+  } catch (error) {
+      console.error('Error spawning ffmpeg:', error);
+      liveView.error(err)
+      liveView.complete()
+      ffmpegProcess = null
+      res.status(500).end()
+  }
+})
+app.post('/stopLiveView', (req, res) => {
+  if (ffmpegProcess) {
+    console.log('stopLiveView, killing ffmpeg')
+    ffmpegProcess.kill('SIGKILL');
+    ffmpegProcess = null;
+    liveView.complete();
+    res.status(200).end();
+  } else {
+    console.log('ffmpeg is not running')
+    res.status(200).end();
+  }
+})
+app.post('/setProperty', (req, res) => {
+  res.status(200).end();
+})
+app.get('/health', (req, res) => {
+  res.setHeader('content-type', 'application/json')
+  res.send({
+    status: 'pass',
+    details: {
+      isSDKLoaded: true,
+      isSessionOpen: true,
+    },
+    version: '999.9'
+  })
+})
+
+// --- Express Server Logic ---
+
+// This doesn't work without calling startLiveView first
+app.get('/', (req, res) => {
+    res.send(`
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Live Webcam Stream (MJPEG)</title>
+            <script src="https://cdn.tailwindcss.com"></script>
+            <style>
+                body {
+                    font-family: 'Inter', sans-serif;
+                    background-color: #f0f2f5;
+                    display: flex;
+                    justify-content: center;
+                    align-items: center;
+                    min-height: 100vh;
+                    margin: 0;
+                }
+                .container {
+                    background-color: #ffffff;
+                    border-radius: 10px;
+                    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+                    padding: 2rem;
+                    text-align: center;
+                    width: 90%;
+                    max-width: 800px;
+                }
+                #videoStream {
+                    width: 100%;
+                    max-width: 720px;
+                    height: auto;
+                    border-radius: 8px;
+                    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+                    margin-top: 1rem;
+                    background-color: #000;
+                    display: block; /* Ensure it takes up full width */
+                    margin-left: auto;
+                    margin-right: auto;
+                }
+                .status-message {
+                    margin-top: 1rem;
+                    font-size: 1rem;
+                    color: #555;
+                }
+                .error-message {
+                    color: #e53e3e;
+                    font-weight: bold;
+                }
+            </style>
+        </head>
+        <body>
+            <div class="container flex flex-col items-center">
+                <h1 class="text-3xl font-bold text-gray-800 mb-4">Live Webcam Stream (MJPEG)</h1>
+                <!-- The img tag's src points directly to the MJPEG stream endpoint -->
+                <img id="videoStream" class="rounded-lg" src="/liveViewImage" alt="Live Webcam Stream">
+                <p id="status" class="status-message">Loading video stream...</p>
+                <button id="refreshButton" class="mt-4 px-6 py-2 bg-blue-500 text-white font-semibold rounded-lg shadow-md hover:bg-blue-600 focus:outline-none focus:ring-2 focus:ring-blue-400 focus:ring-opacity-75">
+                    Refresh Stream
+                </button>
+            </div>
+
+            <script>
+                const videoStream = document.getElementById('videoStream');
+                const statusElement = document.getElementById('status');
+                const refreshButton = document.getElementById('refreshButton');
+
+                // Basic status update for initial load
+                videoStream.onload = () => {
+                    statusElement.textContent = 'Live Streaming...';
+                };
+
+                videoStream.onerror = () => {
+                    statusElement.className = 'status-message error-message';
+                    statusElement.textContent = 'Failed to load stream. Ensure the server is running and FFmpeg is configured correctly.';
+                };
+
+                refreshButton.addEventListener('click', () => {
+                    // Force reload the image source to re-establish the stream
+                    const currentSrc = videoStream.src;
+                    videoStream.src = ''; // Clear src to force reload
+                    videoStream.src = currentSrc.split('?')[0] + '?' + new Date().getTime(); // Add cache busting
+                    statusElement.className = 'status-message';
+                    statusElement.textContent = 'Attempting to reconnect...';
+                });
+
+                // Initial check for stream status (optional, for faster feedback if stream fails immediately)
+                // This doesn't strictly monitor the stream, but can catch initial connection issues.
+                setTimeout(() => {
+                    if (!videoStream.complete && videoStream.naturalWidth === 0) {
+                        statusElement.className = 'status-message error-message';
+                        statusElement.textContent = 'Stream not loading. Check server logs and FFmpeg setup.';
+                    }
+                }, 5000); // Check after 5 seconds
+            </script>
+        </body>
+        </html>
+    `);
+});
+
+// Start the HTTP server
+server.listen(port, () => {
+    console.log(`Webcam streaming server listening at http://localhost:${port}`);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+});
+
+process.on('uncaughtException', (error) => {
+    console.error('Uncaught Exception:', error);
+    if (ffmpegProcess) {
+        ffmpegProcess.kill('SIGKILL');
+        console.log('Killed ffmpeg process due to uncaught exception.');
+    }
+    process.exit(1); // Exit process with failure
+});
+
+function jpegProps(data) {
+  var off = 0;
+  while(off<data.length) {
+      while(data[off]==0xff) off++;
+      var mrkr = data[off];  off++;
+
+      if(mrkr==0xd8) continue;    // SOI
+      if(mrkr==0xd9) break;       // EOI
+      if(0xd0<=mrkr && mrkr<=0xd7) continue;
+      if(mrkr==0x01) continue;    // TEM
+
+      var len = (data[off]<<8) | data[off+1];  off+=2;
+
+      if(mrkr==0xc0) return {
+          bpc : data[off],     // precission (bits per channel)
+          h   : (data[off+1]<<8) | data[off+2],
+          w   : (data[off+3]<<8) | data[off+4],
+          cps : data[off+5]    // number of color components
+      }
+      off+=len-2;
+  }
+}

package/index.js

@@ -0,0 +1,4 @@
+
+const octopus = require('./octopus')
+const printer = require('./printer')
+const camera = require('./camera')

package/octopus.js

@@ -0,0 +1,93 @@
+const express = require('express');
+const cors = require('cors');
+const app = express()
+
+app.use(cors())
+
+app.post('/init', (req, res) => {
+  res.setHeader('content-type', 'application/json')
+  res.send({
+    data: {
+      deviceId: 12345678,
+      isBlacklistOutdated: true,
+    }
+  })
+})
+
+let count = 0
+app.post('/payments', (req, res) => {
+  setTimeout(() => {
+    res.setHeader('content-type', 'application/json')
+    res.send({
+      error: {
+        code: -100,
+      }
+    })
+    // if (count++ % 3 == 2) {
+    //   res.send({
+    //     data: {
+    //       timestamp: Math.floor(Date.now() / 1000),
+    //       deviceId: 12345678,
+    //       receiptNo: 'qwertyasdf',
+    //       cardId: 12345678,
+    //       deductAmount: 60,
+    //       remainingValue: 123,
+    //       octopusType: 1,
+    //       lastAddValueInfo: {
+    //         date: '2024-11-12',
+    //         type: 1,
+    //       },
+    //     }
+    //   })
+    // } else {
+    //   res.send({
+    //     error: {
+    //       extraData: {
+    //         cardId: 123456789,
+    //         receiptNo: 1234567890,
+    //       },
+    //       code: 100022,
+    //     }
+    //   })
+    // }
+  }, 3000)
+})
+
+app.post('/enquiry', (req, res) => {
+  setTimeout(() => {
+    res.send({
+      data: {
+        octopusType: 2,
+        remainingValue: 56.7,
+        cardId: 12345678,
+        cardLogs: [{
+          transactionAmount: -50,
+          transactionTimestamp: Math.floor(Date.now() / 1000),
+          deviceId: 1234,
+          isSameDevice: false,
+        }, {
+          transactionAmount: -12.3,
+          transactionTimestamp: Math.floor(Date.now() / 1000),
+          deviceId: 1234,
+          isSameDevice: false,
+        }, {
+          transactionAmount: 500,
+          transactionTimestamp: Math.floor(Date.now() / 1000),
+          deviceId: 1234,
+          isSameDevice: false,
+        }, {
+          transactionAmount: -0.1,
+          transactionTimestamp: Math.floor(Date.now() / 1000),
+          deviceId: 123456,
+          isSameDevice: true,
+        }],
+      }
+    })
+  }, 5_000)
+})
+
+const port = process.env['ALMAGEST_OCTOPUS_MANAGER_PORT'] ? Number(process.env['ALMAGEST_OCTOPUS_MANAGER_PORT']) : 40082;
+
+app.listen(port, () => {
+  console.log(`Octopus listening on http://localhost:${port}`)
+})

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "snapio-mock-camera",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "commonjs",
+  "scripts": {
+    "start": "nodemon index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "canvas": "^3.0.0-rc2",
+    "cors": "^2.8.5",
+    "express": "^4.17.1",
+    "node-webcam": "^0.8.2",
+    "rxjs": "^7.8.2"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.10"
+  }
+}

package/printer.js

@@ -0,0 +1,38 @@
+const express = require('express');
+const cors = require('cors');
+const fs = require('fs')
+const path = require('path')
+const app = express()
+
+app.use(cors())
+
+let remaining = 100;
+
+app.get('/health', (req, res) => {
+  res.setHeader('content-type', 'application/json')
+  res.send({
+    // status: Math.random() < 0.9 ? 'fail' : 'pass',
+    status: 'pass',
+    message: 'Hello world',
+    remainingMediaQuantity: remaining,
+    details: { printerModel: 'DS620' }
+  })
+})
+app.post('/printPhoto', (req, res) => {
+  const ws = fs.createWriteStream(path.join(__dirname, 'tmp', `${Date.now()}.jpg`))
+  req.pipe(ws)
+  ws.on('finish', () => {
+    res.setHeader('content-type', 'application/json')
+    res.send({
+      data: {
+        remainingMediaQuantity: --remaining,
+      }
+    })
+  })
+})
+
+const port = process.env['SNAPIO_PRINTER_MANAGER_PORT'] ? Number(process.env['SNAPIO_PRINTER_MANAGER_PORT']) : 40080;
+
+app.listen(port, () => {
+  console.log(`Printer listening on http://localhost:${port}`)
+})

package/test-ai.js

@@ -0,0 +1,21 @@
+const fs = require('fs');
+
+(async () => {
+  const IMAGE_SRC = 'public/960x640.jpg';
+  const blob = new File([await fs.openAsBlob(IMAGE_SRC)], 'asdf.jpg', { type: 'image/jpeg' })
+  const formData = new FormData()
+  formData.append('image_1', blob)
+  // formData.append('style', 'cr7')
+  const res = await fetch('https://pons-ai--generation-pipeline-fastapi-app.modal.run/ponsai-generation-pipeline?style=cr7', {
+    method: 'POST',
+    headers: {
+      // 'content-type': 'multipart/form-data',
+      'accept': 'application/json',
+      'Modal-Key': 'wk-rZQi1PiNn6esAt9Mh2GlUs',
+      'Modal-Secret': 'ws-0U18fCTu1Zv6G1yTsvS8ZW'
+    },
+    body: formData
+  })
+  const json = await (res).json();
+  console.log(json)
+})()