Svelte UI Update

api/.dockerignore

@@ -0,0 +1,2 @@
+node_modules
+npm-debug.log

api/.gitignore

@@ -0,0 +1,22 @@
+node_modules/
+public/src/thumbs
+public/avatars/
+# OS generated files #
+######################
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+package-lock.json
+.env
+.env-mongo
+.vscode/
+settings.json
+Procfile
+dump.rdb
+error.log
+output.log
+Dockerfile

api/app.js

@@ -0,0 +1,63 @@
+const express = require("express");
+const app = express();
+const server = require("http").createServer(app);
+const mongoose = require("mongoose");
+const configs = require("./configs");
+const chalk = require("chalk");
+const helmet = require("helmet");
+const morgan = require("morgan");
+const cors = require("cors");
+
+app.use(express.urlencoded({ extended: true }));
+app.use(express.json());
+app.use(helmet());
+
+// Logs
+app.use(morgan("dev"));
+
+app.use(cors());
+// Connect Mongoose
+mongoose
+  .connect(configs.mongodburl, {
+    autoIndex: true
+  })
+  .then(() => {
+    console.log(chalk.cyanBright.bold("Mongodb is live!"));
+  })
+  .catch((error) => {
+    console.log("Mongodb error: " + error.message);
+  });
+
+// Statik dosyaların servis edilmesi
+app.use(express.static("build"));
+
+// React uygulamasının web arayüzüne erişim
+//app.get("/react-ui", (req, res) => {
+//  res.sendFile(path.join(__dirname, "public", "index.html"));
+//});
+
+// Device Set Route
+app.use("/api/get", require("./route/device.get.route"));
+// Save Route
+app.use("/api/save", require("./route/save.route"));
+// Device Set Route
+app.use("/api/set", require("./route/device.set.route"));
+// Device Log Route
+app.use("/api/device-log", require("./route/device.log.route"));
+// 404 Not Found Endpoint
+app.use((req, res) => {
+  res.status(404).json({ error: true, message: error.message });
+});
+// Root public route
+app.use("*", (req, res) => {
+  // res.sendFile("public/", { root: __dirname });
+  res.sendStatus(400);
+});
+// Server Listening
+server.listen(configs.port, () => {
+  console.log(chalk.yellowBright.bold.red("Listening: " + configs.port));
+});
+// Error Handling
+app.on("eror", (error) => {
+  console.log(error);
+});

api/configs/index.js

@@ -0,0 +1,38 @@
+// Settings environments
+require("dotenv").config();
+
+const config = {
+  // Site Url
+  baseURL: process.env.BASE_URL,
+  port: process.env.PORT || 3000,
+  // Veridy Token
+  verifyToken: process.env.VERIFY_TOKEN,
+  // If the Remember me option is not selected
+  cookieExpirationTimeRememberTrue: parseInt(process.env.COOKIE_EXP_TIME_REMEMBER_TRUE), // 1 mounth
+  // Remember me option is selected
+  cookieExpirationTimeRememberFalse: parseInt(process.env.COOKIE_EXP_TIME_REMEMBER_FALSE), // 30 minute
+  // Token Settings
+  tookenExpirationTime: parseInt(process.env.TOOKEN_EXP_TIME), // 1 mounth
+  secret: process.env.SECRET,
+  // Crypt Salt Secret
+  cryptoSalt: process.env.CRYPTO_SALT,
+  // Avatar upload settings
+  avatarNameLength: 15,
+  avatarSizeLimit: 250000, // 250 KB
+  avatarFileTypes: /jpeg|jpg|png/,
+  // Mongo Settings
+  //mongodburl: process.env.MONGODB_URI_PRO,
+  mongodburl: process.env.MONGODB_URI,
+  // mongodburl: 'mongodb://mongo:27017/jwt' //server
+  // The Movie DB api key
+  tmdbApiKey: process.env.TMDB_API_KEY,
+  // Flixinfo api default language
+  thmdbDefaultLanguage: "en-US",
+  // Redis Cache değerleri
+  redisCacheLength: parseInt(process.env.REDIS_CACHE_LENGTH) || 100, // server başladığında ilk chachelenecek kayıt miktarı
+  redisTTL: parseInt(process.env.REDIS_TTL) || 86400, // veriler ne kadar süre cachede tutulacak
+  //redisUrl: process.env.REDIS_URL_PRO,
+  redisUrl: process.env.REDIS_URL,
+};
+
+module.exports = config;

api/controller/device.get.controller.js

@@ -0,0 +1,31 @@
+const configs = require("../configs");
+const DeviceModel = require("../models/device.model");
+
+const get = async (token, device_id) => {
+  if (token === configs.verifyToken) {
+    console.log(device_id);
+    try {
+      if (!device_id) {
+        // device_id verilmemişse bütün cihazalara ait bilgileri getir
+        const result = await DeviceModel.find({});
+        return result;
+      } else {
+        // device_id verilmişse sadece o cihaza ait bilgi getir
+        const result = await DeviceModel.findOne({
+          _id: device_id
+        });
+        if (result) {
+          return result;
+        } else {
+          throw new Error("Cihaz bulunamadı!");
+        }
+      }
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  } else {
+    throw new Error("Hatalı token (set.controller)");
+  }
+};
+
+module.exports = { get };

api/controller/device.log.controller.js

@@ -0,0 +1,29 @@
+const configs = require("../configs");
+const Library = require("../library");
+
+const logSave = async (
+  token,
+  device_id,
+  remote_name,
+  remote_type,
+  operating_type
+) => {
+  if (token === configs.verifyToken) {
+    try {
+      const result = await Library.saveDeviceLog(
+        device_id,
+        remote_name,
+        remote_type,
+        operating_type
+      );
+
+      return result;
+    } catch (error) {
+      throw new Error("Mongodb'ye kaydedilirken hata oluştu (log.controller)");
+    }
+  } else {
+    throw new Error("Hatalı token (log.controller)");
+  }
+};
+
+module.exports = { logSave };

api/controller/device.set.controller.js

@@ -0,0 +1,53 @@
+const configs = require("../configs");
+const Library = require("../library");
+const DeviceModel = require("../models/device.model");
+const fetch = require("node-fetch");
+
+const set = async (
+  token,
+  device_id,
+  remote_name,
+  remote_type,
+  operating_type
+) => {
+  if (token === configs.verifyToken) {
+    try {
+      const deviceExist = await DeviceModel.findOne({
+        _id: device_id
+      });
+      if (deviceExist) {
+        const hostname = deviceExist.device_ip_address;
+        const response = await fetch(
+          "http://" +
+            hostname +
+            "/" +
+            operating_type +
+            "?token=" +
+            configs.verifyToken
+        );
+
+        const isOpen = await response.text();
+        console.log(isOpen);
+        if (isOpen === "true") {
+          Library.saveDeviceLog(
+            device_id,
+            remote_name,
+            remote_type,
+            operating_type
+          );
+          return operating_type + " işlemi başarılı!";
+        } else {
+          throw new Error("Client message: " + isOpen);
+        }
+      } else {
+        throw new Error("Cihaz bulunamadı!");
+      }
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  } else {
+    throw new Error("Hatalı token (set.controller)");
+  }
+};
+
+module.exports = { set };

api/controller/save.controller.js

@@ -0,0 +1,94 @@
+const configs = require("../configs");
+const DeviceModel = require("../models/device.model");
+
+const save = async (
+  token,
+  device_name,
+  device_type,
+  manifactor,
+  serial_number,
+  model,
+  firmware_version,
+  device_ip_address,
+  sensor_value,
+  battery_life
+) => {
+  if (token === configs.verifyToken) {
+    try {
+      // Önce kaydı bulalım
+      const existingDevice = await DeviceModel.findOne({
+        device_name,
+        device_type,
+        manifactor,
+        serial_number,
+        model,
+        firmware_version
+      });
+      if (!existingDevice) {
+        // İlk defa kaydet
+        const newDevice = new DeviceModel({
+          device_name,
+          device_type,
+          manifactor,
+          serial_number,
+          model,
+          firmware_version,
+          device_ip_address,
+          update_time: new Date(Date.now()),
+          device_log: {
+            sensor_value,
+            battery_life
+          }
+        });
+        const result = await newDevice.save();
+        return "Cihaz kaydedildi.";
+      } else {
+        // Daha önce kaydedilmiş ise sadece ip adresini güncelle
+        const filter = {
+          device_name,
+          device_type,
+          manifactor,
+          serial_number,
+          model,
+          firmware_version
+        };
+
+        let update;
+
+        if (sensor_value === undefined && battery_life === undefined) {
+          update = {
+            $set: {
+              device_ip_address,
+              update_time: new Date(Date.now()),
+            }
+          };
+        } else {
+          update = {
+            $set: {
+              device_ip_address,
+              update_time: new Date(Date.now()),
+              device_log: {
+                sensor_value,
+                battery_life
+              }
+            }
+          };
+        }
+
+        const result = await DeviceModel.updateOne(filter, update);
+
+        if (result.nModified === 0) {
+          throw new Error("Güncellenmek istenen kayıt bulunamadı");
+        }
+
+        return "IP Adresi güncellendi";
+      }
+    } catch (error) {
+      throw new Error("Mongodb: " + error.message + " (save.controller)");
+    }
+  } else {
+    throw new Error("Hatalı token (save.controller)");
+  }
+};
+
+module.exports = { save };

api/docker-compose.yml

@@ -0,0 +1,48 @@
+version: "3"
+services:
+  web:
+    build: .
+    volumes:
+      - ./:/smarthome
+      - /smarthome/node_modules
+    ports:
+      - "9095:9095"
+    restart: always
+    links:
+      # - redis
+      - mongo
+    tty: true
+    environment:
+      DEBUG_COLORS: "true"
+      TERM: xterm-256color
+      COLORTERM: truecolor
+    networks:
+      - smarthome
+  mongo:
+    container_name: mongo
+    image: mongo:4.2.5
+    restart: always
+    env_file: .env-mongo
+    ports: ["27017:27017"]
+    networks:
+      - smarthome
+  mongo-express:
+    container_name: mongo-express
+    image: mongo-express
+    restart: always
+    ports:
+      - "8081:8081"
+    env_file: .env-mongo
+    depends_on:
+      - mongo
+    networks:
+      - smarthome
+  # redis:
+  #   container_name: redis
+  #   image: redis:5.0.8
+  #   restart: always
+  #   command: ["redis-server", "--bind", "redis", "--port", "6379"]
+  #   ports: ["6379:6379"]
+
+networks:
+  smarthome:

api/library/index.js

@@ -0,0 +1,39 @@
+const configs = require("../configs");
+const DeviceModel = require("../models/device.model");
+
+const saveDeviceLog = async (
+  device_id,
+  remote_name,
+  remote_type,
+  operating_type
+) => {
+  try {
+    // Önce kaydı bulalım
+    const filter = {
+      _id: device_id
+    };
+
+    const update = {
+      $push: {
+        device_log: {
+          remote_name,
+          remote_type,
+          operating_type,
+          log_time: new Date(Date.now())
+        }
+      }
+    };
+
+    const result = await DeviceModel.updateOne(filter, update);
+
+    if (result.nModified === 0) {
+      throw new Error("Güncellenmek istenen kayıt bulunamadı (library)");
+    }
+
+    return "Log Kaydedildi!";
+  } catch (error) {
+    throw new Error("Mongodb'ye kaydedilirken hata oluştu (library)");
+  }
+};
+
+module.exports = { saveDeviceLog };

api/models/device.model.js

@@ -0,0 +1,59 @@
+const mongoose = require("mongoose");
+
+const Schema = mongoose.Schema;
+
+const deviceLogSchema = new Schema({
+  remote_name: {
+    type: String
+  },
+  remote_type: {
+    type: String
+  },
+  operating_type: {
+    type: String // Toggle - Homekit Reset - Reset
+  },
+  log_time: {
+    type: String
+  },
+  sensor_value: {
+    type: Number
+  },
+  battery_life: {
+    type: Number
+  }
+});
+
+const deviceSchema = new Schema({
+  device_name: {
+    type: String,
+    unique: true
+  },
+  device_type: {
+    type: String
+  },
+  manifactor: {
+    type: String
+  },
+  serial_number: {
+    type: String,
+    unique: true
+  },
+  model: {
+    type: String
+  },
+  firmware_version: {
+    type: String
+  },
+  device_ip_address: {
+    type: String,
+    unique: true
+  },
+  update_time: {
+    type: String
+  },
+  device_log: [deviceLogSchema]
+});
+
+const Device = mongoose.model("Device", deviceSchema);
+
+module.exports = Device;

api/package.json

@@ -0,0 +1,25 @@
+{
+  "dependencies": {
+    "chalk": "^4.0.0",
+    "cors": "^2.8.5",
+    "create-react-app": "^5.0.1",
+    "dotenv": "^16.4.5",
+    "express": "^4.18.2",
+    "helmet": "^7.1.0",
+    "mongoose": "^8.2.0",
+    "morgan": "^1.10.0",
+    "node-fetch": "^2.7.0",
+    "nodemon": "^3.1.0",
+    "socket.io": "^4.7.4"
+  },
+  "name": "wisecolt-mancmini",
+  "version": "1.0.0",
+  "main": "app.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "keywords": [],
+  "description": ""
+}

api/route/device.get.route.js

@@ -0,0 +1,28 @@
+const express = require("express");
+const router = express.Router();
+const DeviceGetController = require("../controller/device.get.controller");
+
+router.use(express.urlencoded({ extended: false }));
+router.use(express.json());
+
+// Device Log Save route
+router.get("/:token/:device_id?", async (req, res) => {
+  try {
+    const { token, device_id } = req.params;
+
+    // Token Control Middleware
+    const result = await DeviceGetController.get(token, device_id);
+
+    return res.status(200).json({
+      error: false,
+      result
+    });
+  } catch (error) {
+    res.status(400).json({
+      error: true,
+      result: error.message
+    });
+  }
+});
+
+module.exports = router;

api/route/device.log.route.js

@@ -0,0 +1,32 @@
+const express = require("express");
+const router = express.Router();
+const DeviceLogController = require("../controller/device.log.controller");
+
+router.use(express.urlencoded({ extended: false }));
+router.use(express.json());
+
+// Device Log Save route
+router.post("/", async (req, res) => {
+  try {
+    // Token Control Middleware
+    const result = await DeviceLogController.logSave(
+      req.body.token,
+      req.body.device_id,
+      req.body.remote_name,
+      req.body.remote_type,
+      req.body.operating_type,
+    );
+
+    return res.status(200).json({
+      error: false,
+      result
+    });
+  } catch (error) {
+    res.status(400).json({
+      error: true,
+      result: error.message
+    });
+  }
+});
+
+module.exports = router;

api/route/device.set.route.js

@@ -0,0 +1,40 @@
+const express = require("express");
+const router = express.Router();
+const DeviceSetController = require("../controller/device.set.controller");
+
+router.use(express.urlencoded({ extended: false }));
+router.use(express.json());
+
+// Device Log Save route
+router.get(
+  "/:operating_type/:token/:device_id/:remote_name/:remote_type",
+  async (req, res) => {
+    try {
+      const { token, device_id, remote_name, remote_type, operating_type } =
+        req.params;
+
+        console.log(req.params);
+
+      // Token Control Middleware
+      const result = await DeviceSetController.set(
+        token,
+        device_id,
+        remote_name,
+        remote_type,
+        operating_type
+      );
+
+      return res.status(200).json({
+        error: false,
+        result
+      });
+    } catch (error) {
+      res.status(400).json({
+        error: true,
+        result: error.message
+      });
+    }
+  }
+);
+
+module.exports = router;

api/route/save.route.js

@@ -0,0 +1,38 @@
+const express = require("express");
+const router = express.Router();
+const SaveController = require("../controller/save.controller");
+
+router.use(express.urlencoded({ extended: false }));
+router.use(express.json())
+
+// Save route
+router.post("/", async (req, res) => {
+
+  try {
+    // Token Control Middleware
+    const result = await SaveController.save(
+      req.body.token,
+      req.body.device_name,
+      req.body.device_type,
+      req.body.manifactor,
+      req.body.serial_number,
+      req.body.model,
+      req.body.firmware_version,
+      req.body.device_ip_address,
+      req.body.sensor_value,
+      req.body.battery_life,
+    );
+
+    return res.status(200).json({
+      error: false,
+      result
+    });
+  } catch (error) {
+    res.status(400).json({
+      error: true,
+      result: error.message
+    });
+  }
+});
+
+module.exports = router;