Log_service/start/routes.ts

import fs from 'fs';
import axios from "axios";
/*
|--------------------------------------------------------------------------
| Routes
|--------------------------------------------------------------------------
|
| This file is dedicated for defining HTTP routes. A single file is enough
| for majority of projects, however you can define routes in different
| files and just make sure to import them inside this file. For example
|
| Define routes in following two files
| ├── start/routes/cart.ts
| ├── start/routes/customer.ts
|
| and then import them inside `start/routes.ts` as follows
|
| import './routes/cart'
| import './routes/customer'
|
*/

import Route from "@ioc:Adonis/Core/Route";
import LogDetectFile from "App/Models/LogDetectFile";
import { runtimeCheckLogs } from "App/utils/runtimeCheckLogs";
import Env from "@ioc:Adonis/Core/Env";
import KeyValue from "App/Models/KeyValue";
import ErpsController from "App/Controllers/Http/ErpsController";
import LogReport from "App/Models/LogReport";
import Database from "@ioc:Adonis/Lucid/Database";
import { exec } from "child_process";
import ImagesController from 'App/Controllers/Http/ImagesController';
import { uploadFileToZulip } from 'App/utils/uploadFileZulip';
import { screenShot } from 'App/utils/screenShot';
import { sendMessToZulip } from 'App/utils/sendMessToZulip';

runtimeCheckLogs(Env.get("FOLDER_LOGS"));

//ERP get index serial number
Route.post(
  "/api/getIndexSerialNumber",
  "ErpsController.getIndexSerialNumber"
).middleware("checkToken");
Route.post("/api/getParagraph", "ErpsController.getParagraph").middleware(
  "checkToken"
);

//Users
Route.post("/api/account/createUser", "UsersController.create");
Route.post("/api/account/checkLogin", "UsersController.checkLogin");

//Log
Route.get("/api/log/showLog/:name?", async ({ request, response }) => {
  try {
    // fghf
    console.log(request.params().name);
    let fileDetect = await LogDetectFile.findBy(
      "file_name",
      request.params().name
    );
    let logsDetect = await Database.rawQuery(
      "select * from log_reports where id_file = " + fileDetect?.id_ldf
    );

    let modelSpecialDetected = [];
    let issueSpecialDetected = [];
    let listLine = logsDetect[0]
      .map((obj) => obj.line)
      .filter((value, index, self) => {
        return self.indexOf(value) === index;
      })
      .sort((a, b) => a - b);

    const content = await axios.get(
      request.params().name.search("AUTO")!==-1?"http://192.168.5.7:8080/AUTOlog/" + request.params().name
      :"http://192.168.5.7:8080/" + request.params().name
    );
    let allValue = await KeyValue.all();
    let listKeyValues = allValue.filter(
      (i) =>
        i.$original.key === "MODEL_SPECIAL" ||
        i.$original.key === "CATCH_FAULTY"
    );

    let MODEL_SPECIAL = allValue
      .filter((i) => i.$original.key === "MODEL_SPECIAL")
      .map((obj) => obj.$original.value);

    let listExcludeErr = allValue
      .filter((i) => i.$original.key === "EXCLUDE_ERR")
      .map((obj) => obj.$original.value);

    let data = content.data.split("\n");
    data.map((line, index) => {
      data[index] = index + 1 + "|-|" + line;
      listKeyValues
        .map((obj) => obj.$original.value)
        .map(async (value) => {
          if (
            line.search(value) !== -1 &&
            listExcludeErr.filter((err) => line.includes(err)).length === 0
          ) {
            data[index] =
              data[index].slice(0, data[index].search(value)) +"|-|" +
              value +
              "|-|" +
              data[index].slice(data[index].search(value) + value.length);
            // }
          }
        });
    });

    listLine.map((u) => {
      if (
        listExcludeErr.filter((err) => data[u - 1].includes(err)).length === 0
      ) {
        if (MODEL_SPECIAL.filter((i) => data[u - 1].includes(i)).length > 0) {
          modelSpecialDetected.push(data[u - 1]);
        } else {
          issueSpecialDetected.push(data[u - 1]);
        }
      }
    });
    let modelSpecial =
      modelSpecialDetected.length > 0 ? modelSpecialDetected.join("\n") : "";
    let issueItem =
      issueSpecialDetected.length > 0 ? issueSpecialDetected.join("\n") : "";
    response
      .status(200)
      .send({
        modelSpecial: modelSpecial,
        issueItem: issueItem,
        contentFile: data.join("\n"),
      });
  } catch (error) {
    // console.error(error);
    response
    .status(203)
    .send("FILE NOT FOUND");
  }
});

Route.get("/api/getAllLogDetect", async ({ request, response }) => {
  try {
    let fileDetect = await LogDetectFile.all()
    let listFiles = fileDetect.map(obj=>obj.file_name)
    response
      .status(200)
      .send(listFiles);
  } catch (error) {
    response
    .status(203)
    .send("NO FILE");
  }
});
//Key-Value

Route.post("/api/getKeyValue", async ({ request, response }) => {
  let data = await KeyValue.all();
  response.status(200).send(data);
});

Route.post("/api/deleteValue", async ({ request, response }) => {
  try {
    const value = await KeyValue.findOrFail(request.all().id);
    await value.delete();
    response.status(200).send("DELETE VALUE SUCCESS!");
  } catch (error) {
    response.status(500).send("DELETE VALUE FAIL!");
  }
});

Route.post("/api/addValue", async ({ request, response }) => {
  try {
    const value = await KeyValue.create({
      key: request.all().key,
      value: request.all().value,
      model: "All",
    });
    response.status(200).send("ADD VALUE SUCCESS!");
  } catch (error) {
    response.status(500).send("ADD VALUE FAIL!");
  }
});

Route.post("/api/gitea-webhook", ({ request, response }) => {
  
  console.log("New event ---> ", request.header("x-gitea-event"));

  exec(
    Env.get("URL_FILE_SHELL"),
    async(error, stdout, stderr) => {
      if (error) {
        console.error(`Error executing command: ${error}`);
        return;
      }

      const res = await sendMessToZulip("direct", [45], "none", "** NEW EVENT -> "+request.header("x-gitea-event")+" **"+stdout )
      console.log(res)
      console.log(`Command output:\n${stdout}`);
    }
  );
});

// Route.get('/api/images/:filename', "ImagesController.getImage");