import amqp from "amqplib";
import { AppDataSource } from "../database/data-source";
import { Command } from "../entities/Command";
import { commandTypePath } from "../interfaces/utils";
import CallAPI from "../interfaces/call-api";
import HttpError from "../interfaces/http-error";
import HttpStatusCode from "../interfaces/http-status";
import { RequestWithUser } from "../middlewares/user";
import { PosMaster } from "../entities/PosMaster";
import { Profile } from "../entities/Profile";
import { EmployeePosMaster } from "../entities/EmployeePosMaster";
import { EmployeeTempPosMaster } from "../entities/EmployeeTempPosMaster";
import { ProfileEmployee } from "../entities/ProfileEmployee";
import { OrgRevision } from "../entities/OrgRevision";
import { request } from "http";
import { EmployeePosition } from "../entities/EmployeePosition";
import { OrgChild1 } from "../entities/OrgChild1";
import { OrgChild2 } from "../entities/OrgChild2";
import { OrgChild3 } from "../entities/OrgChild3";
import { OrgChild4 } from "../entities/OrgChild4";
import { OrgRoot } from "../entities/OrgRoot";
import { PosMasterAssign } from "../entities/PosMasterAssign";
import { Position } from "../entities/Position";
import { In, Not } from "typeorm";
import { PosMasterAct } from "../entities/PosMasterAct";
import { PermissionOrg } from "../entities/PermissionOrg";

export let sendToQueue: (payload: any) => void;
export let sendToQueueOrg: (payload: any) => void;
export let sendToQueueOrgDraft: (payload: any) => void;
export async function init() {
  //----> (1) Producer
  if (!process.env.AMQ_URL || !process.env.AMQ_QUEUE || !process.env.AMQ_QUEUE_ORG || !process.env.AMQ_QUEUE_ORG_DRAFT) return;

  const { AMQ_URL: url, AMQ_QUEUE: queue, AMQ_QUEUE_ORG: queue_org, AMQ_QUEUE_ORG_DRAFT: queue_org_draft } = process.env; //----> (1.2) get url and queue from .env

  const connection = await amqp.connect(url); //----> (1.3) set up url with amqp protocol

  console.log(connection ? "[AMQ] Connection success" : "[AMQ] Connection failed");

  const channel = await connection.createChannel(); //----> (1.4) create Channel

  console.log(channel ? "[AMQ] Create channel success" : "[AMQ] Create channel failed");

  channel.assertQueue(queue, { durable: true }), //----> (1.5) assert queue and set durable (if "true" save to disk on RabbitMQ)
  channel.assertQueue(queue_org, { durable: true }),
  channel.assertQueue(queue_org_draft, { durable: true }),
  channel.prefetch(1);

  sendToQueue = (payload: any, persistent = true) => {
    //----> (2) sendQueue To RabbitMQ and set persistent (if "true" redo the failed queue when server run again)
    channel.sendToQueue(queue, Buffer.from(JSON.stringify(payload)), {
      persistent,
    });
  };

  sendToQueueOrg = (payload: any, persistent = true) => {
    channel.sendToQueue(queue_org, Buffer.from(JSON.stringify(payload)), { persistent });
  };

  sendToQueueOrgDraft = (payload: any, persistent = true) => {
    channel.sendToQueue(queue_org_draft, Buffer.from(JSON.stringify(payload)), { persistent });
  };

  console.log("[AMQ] Listening for message...");
  createConsumer(queue, channel, handler), //----> (3) Process Consumer
  createConsumer(queue_org, channel, handler_org);
  createConsumer(queue_org_draft, channel, handler_org_draft);
  // createConsumer(queue2, channel, handler2);
}

let retries = 0;

function createConsumer( //----> consumer
  queue: string,
  channel: amqp.Channel,
  handler: (msg: amqp.ConsumeMessage) => Promise<boolean> | boolean,
) {
  channel.consume(
    queue,
    async (msg) => {
      if (!msg) return;
      if ((await handler(msg)) || retries++ >= 3) {
        retries = 0;
        console.log("[AMQ] Process Consumer success");
        return channel.ack(msg);
      }
      console.log("[AMQ] Process Consumer failed");
      return await new Promise((resolve) => setTimeout(() => resolve(channel.nack(msg)), 3000));
    },
    { noAck: false },
  );
}

async function handler(msg: amqp.ConsumeMessage): Promise<boolean> {
  //----> condition before process consumer
  const repo = AppDataSource.getRepository(Command);
  const { data, token, user } = JSON.parse(msg.content.toString());
  const { id, status, lastUpdateUserId, lastUpdateFullName, lastUpdatedAt } = data;
  const command = await repo.findOne({
    where: { id: id },
    relations: ["commandType", "commandRecives"],
  });
  if (!command) return true;
  const path = commandTypePath(command.commandType.code);
  if (path == null) throw new HttpError(HttpStatusCode.NOT_FOUND, "ไม่พบประเภทคำสั่งนี้ในระบบ");
  return await new CallAPI()

    .PostData(
      {
        headers: { authorization: token },
      },
      path + "/excecute",
      {
        refIds: command.commandRecives
          .filter((x) => x.refId != null)
          .map((x) => ({
            refId: x.refId,
            commandNo: command.commandNo,
            commandYear: command.commandYear,
            commandId: command.id,
            remark: command.positionDetail,
            amount: x.amount,
            amountSpecial: x.amountSpecial,
            positionSalaryAmount: x.positionSalaryAmount,
            mouthSalaryAmount: x.mouthSalaryAmount,
            commandCode: command.commandType.commandCode,
            commandName: command.commandType.name,
            commandDateAffect: command.commandExcecuteDate,
            commandDateSign: command.commandAffectDate,
          })),
      },
      false,
    )
    .then(async (res) => {
      console.log("[AMQ] Excecute Command Success");
      Object.assign(command, { status, lastUpdateUserId, lastUpdateFullName, lastUpdatedAt });
      const result = await repo.save(command).catch((e) => console.log(e));
      if (result) return true;
      return false;
    })
    .catch((e) => {
      console.error(e);
      return false;
    });
}

async function handler_org(msg: amqp.ConsumeMessage): Promise<boolean> {
  //----> condition before process consume
  const repoPosmaster = AppDataSource.getRepository(PosMaster);
  const repoEmployeePosmaster = AppDataSource.getRepository(EmployeePosMaster);
  const repoEmployeeTempPosmaster = AppDataSource.getRepository(EmployeeTempPosMaster);
  const repoProfile = AppDataSource.getRepository(Profile);
  const repoProfileEmployee = AppDataSource.getRepository(ProfileEmployee);
  const employeePositionRepository = AppDataSource.getRepository(EmployeePosition);
  const repoOrgRevision = AppDataSource.getRepository(OrgRevision);
  const orgRootRepository = AppDataSource.getRepository(OrgRoot);
  const child1Repository = AppDataSource.getRepository(OrgChild1);
  const child2Repository = AppDataSource.getRepository(OrgChild2);
  const child3Repository = AppDataSource.getRepository(OrgChild3);
  const child4Repository = AppDataSource.getRepository(OrgChild4);

  const orgRevisionPublish = await repoOrgRevision
    .createQueryBuilder("orgRevision")
    .where("orgRevision.orgRevisionIsDraft = false")
    .andWhere("orgRevision.orgRevisionIsCurrent = true")
    .getOne();

  const orgRevisionDraft = await repoOrgRevision
    .createQueryBuilder("orgRevision")
    .where("orgRevision.orgRevisionIsDraft = true")
    .andWhere("orgRevision.orgRevisionIsCurrent = false")
    .getOne();
  if (orgRevisionPublish) {
    orgRevisionPublish.orgRevisionIsDraft = false;
    orgRevisionPublish.orgRevisionIsCurrent = false;
    await repoOrgRevision.save(orgRevisionPublish);
  }
  if (orgRevisionDraft) {
    orgRevisionDraft.orgRevisionIsCurrent = true;
    orgRevisionDraft.orgRevisionIsDraft = false;
    await repoOrgRevision.save(orgRevisionDraft);
  }

  const { data, token, user } = JSON.parse(msg.content.toString());
  const { id, status, lastUpdateUserId, lastUpdateFullName, lastUpdatedAt } = data;
  try {
    const posMaster = await repoPosmaster.find({
      where: { orgRevisionId: id },
      relations: [
        "orgRoot",
        "orgChild4",
        "orgChild3",
        "orgChild2",
        "orgChild1",
        "positions",
        "positions.posLevel",
        "positions.posType",
        "positions.posExecutive",
      ],
    });
    for (const item of posMaster) {
      if (item.next_holderId != null) {
        const profile = await repoProfile.findOne({
          where: { id: item.next_holderId == null ? "" : item.next_holderId },
        });
        const position = await item.positions.find((x) => x.positionIsSelected == true);
        const _null: any = null;
        if (profile != null) {
          profile.posLevelId = position?.posLevelId ?? _null;
          profile.posTypeId = position?.posTypeId ?? _null;
          profile.position = position?.positionName ?? _null;
          await repoProfile.save(profile);
        }
      }
      item.current_holderId = item.next_holderId;
      item.next_holderId = null;
      item.lastUpdateUserId = lastUpdateUserId;
      item.lastUpdateFullName = lastUpdateFullName;
      item.lastUpdatedAt = lastUpdatedAt;
      await repoPosmaster.save(item).catch((e) => console.log(e));
    }
    if (orgRevisionPublish != null && orgRevisionDraft != null) {
      //new main revision
      const before = null;

      //cone tree
      // if (
      //   orgRevisionPublish.typeDraft.toUpperCase() == "ORG" ||
      //   orgRevisionPublish.typeDraft.toUpperCase() == "ORG_POSITION" ||
      //   orgRevisionPublish.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
      //   orgRevisionPublish.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
      //   orgRevisionPublish.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
      // ) {
      //หา dna tree
      const orgRoot = await orgRootRepository.find({
        where: { orgRevisionId: orgRevisionPublish.id },
      });

      const orgChild1 = await child1Repository.find({
        where: { orgRevisionId: orgRevisionPublish.id },
      });

      const orgChild2 = await child2Repository.find({
        where: { orgRevisionId: orgRevisionPublish.id },
      });

      const orgChild3 = await child3Repository.find({
        where: { orgRevisionId: orgRevisionPublish.id },
      });

      const orgChild4 = await child4Repository.find({
        where: { orgRevisionId: orgRevisionPublish.id },
      });

      //หา dna posmaster ถ้าไม่มีให้เอาตัวเองเป็น dna
      const orgemployeePosMaster = await repoEmployeePosmaster.find({
        where: { orgRevisionId: orgRevisionPublish.id },
        relations: ["positions"],
      });

      let _orgemployeePosMaster: EmployeePosMaster[];
      //   if (
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
      //   ) {
      _orgemployeePosMaster = orgemployeePosMaster.map((x) => ({
        ...x,
        ancestorDNA:
          x.ancestorDNA == null || x.ancestorDNA == "00000000-0000-0000-0000-000000000000"
            ? x.id
            : x.ancestorDNA,
      }));
      await repoEmployeePosmaster.save(_orgemployeePosMaster);
      //   }
      //หา dna posmaster ถ้าไม่มีให้เอาตัวเองเป็น dna
      const orgemployeeTempPosMaster = await repoEmployeeTempPosmaster.find({
        where: { orgRevisionId: orgRevisionPublish.id },
        relations: ["positions"],
      });

      let _orgemployeeTempPosMaster: EmployeeTempPosMaster[];
      //   if (
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
      //   ) {
      _orgemployeeTempPosMaster = orgemployeeTempPosMaster.map((x) => ({
        ...x,
        ancestorDNA:
          x.ancestorDNA == null || x.ancestorDNA == "00000000-0000-0000-0000-000000000000"
            ? x.id
            : x.ancestorDNA,
      }));
      await repoEmployeeTempPosmaster.save(_orgemployeeTempPosMaster);
      //   }

      //create org
      orgRoot.forEach(async (x: any) => {
        var dataId = x.id;
        // if (
        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
        // ) {
        //create employeePosmaster
        await Promise.all(
          _orgemployeePosMaster
            .filter((x: EmployeePosMaster) => x.orgRootId == dataId && x.orgChild1Id == null)
            .map(async (item: any) => {
              delete item.id;
              const employeePosMaster = Object.assign(new EmployeePosMaster(), item);
              employeePosMaster.positions = [];
              // if (
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
              // ) {
              //   employeePosMaster.current_holderId = item.current_holderId;
              // } else {
              //   // employeePosMaster.next_holderId = null;
              //   employeePosMaster.isSit = false;
              // }
              // if (
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
              // ) {
              //   employeePosMaster.authRoleId = item.authRoleId;
              // } else {
              //   employeePosMaster.authRoleId = null;
              // }
              //   employeePosMaster.current_holderId = null;
              employeePosMaster.orgRevisionId = orgRevisionDraft.id;
              employeePosMaster.orgRootId = dataId;
              employeePosMaster.createdUserId = "";
              employeePosMaster.createdFullName = "System Administrator";
              employeePosMaster.createdAt = new Date();
              employeePosMaster.lastUpdateUserId = "";
              employeePosMaster.lastUpdateFullName = "System Administrator";
              employeePosMaster.lastUpdatedAt = new Date();
              await repoEmployeePosmaster.save(employeePosMaster);

              //create employeePosition
              item.positions.map(async (pos: any) => {
                delete pos.id;
                const employeePosition: EmployeePosition = Object.assign(
                  new EmployeePosition(),
                  pos,
                );
                employeePosition.posMasterId = employeePosMaster.id;
                //   if (
                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                //   ) {
                //     employeePosition.positionIsSelected = false;
                //   }
                employeePosition.createdUserId = "";
                employeePosition.createdFullName = "System Administrator";
                employeePosition.createdAt = new Date();
                employeePosition.lastUpdateUserId = "";
                employeePosition.lastUpdateFullName = "System Administrator";
                employeePosition.lastUpdatedAt = new Date();
                await employeePositionRepository.save(employeePosition);
              });
            }),
        );
        //create employeeTempPosmaster
        await Promise.all(
          _orgemployeeTempPosMaster
            .filter((x: EmployeeTempPosMaster) => x.orgRootId == dataId && x.orgChild1Id == null)
            .map(async (item: any) => {
              delete item.id;
              const employeeTempPosMaster = Object.assign(new EmployeeTempPosMaster(), item);
              employeeTempPosMaster.positions = [];
              // if (
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
              // ) {
              //   employeeTempPosMaster.current_holderId = item.current_holderId;
              // } else {
              //   // employeeTempPosMaster.next_holderId = null;
              //   employeeTempPosMaster.isSit = false;
              // }
              // if (
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
              // ) {
              //   employeeTempPosMaster.authRoleId = item.authRoleId;
              // } else {
              //   employeeTempPosMaster.authRoleId = null;
              // }
              //   employeeTempPosMaster.current_holderId = null;
              employeeTempPosMaster.orgRevisionId = orgRevisionDraft.id;
              employeeTempPosMaster.orgRootId = dataId;
              employeeTempPosMaster.createdUserId = "";
              employeeTempPosMaster.createdFullName = "System Administrator";
              employeeTempPosMaster.createdAt = new Date();
              employeeTempPosMaster.lastUpdateUserId = "";
              employeeTempPosMaster.lastUpdateFullName = "System Administrator";
              employeeTempPosMaster.lastUpdatedAt = new Date();
              await repoEmployeeTempPosmaster.save(employeeTempPosMaster);

              //create employeePosition
              item.positions.map(async (pos: any) => {
                delete pos.id;
                const employeePosition: EmployeePosition = Object.assign(
                  new EmployeePosition(),
                  pos,
                );
                //   employeePosition.posMasterTempId = employeeTempPosMaster.id;
                //   if (
                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                //   ) {
                //     employeePosition.positionIsSelected = false;
                //   }
                employeePosition.createdUserId = "";
                employeePosition.createdFullName = "System Administrator";
                employeePosition.createdAt = new Date();
                employeePosition.lastUpdateUserId = "";
                employeePosition.lastUpdateFullName = "System Administrator";
                employeePosition.lastUpdatedAt = new Date();
                await employeePositionRepository.save(employeePosition);
              });
            }),
        );
        // }

        //create org
        orgChild1
          .filter((x: OrgChild1) => x.orgRootId == dataId)
          .forEach(async (x: any) => {
            var data1Id = x.id;
            // if (
            //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
            //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
            //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
            //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
            // ) {
            //create employeePosmaster
            await Promise.all(
              _orgemployeePosMaster
                .filter((x: EmployeePosMaster) => x.orgChild1Id == data1Id && x.orgChild2Id == null)
                .map(async (item: any) => {
                  delete item.id;
                  const employeePosMaster = Object.assign(new EmployeePosMaster(), item);
                  employeePosMaster.positions = [];
                  // if (
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                  // ) {
                  //   employeePosMaster.current_holderId = item.current_holderId;
                  // } else {
                  //   // employeePosMaster.next_holderId = null;
                  //   employeePosMaster.isSit = false;
                  // }
                  // if (
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                  // ) {
                  //   employeePosMaster.authRoleId = item.authRoleId;
                  // } else {
                  //   employeePosMaster.authRoleId = null;
                  // }
                  //   employeePosMaster.current_holderId = null;
                  employeePosMaster.orgRevisionId = orgRevisionDraft.id;
                  employeePosMaster.orgRootId = dataId;
                  employeePosMaster.orgChild1Id = data1Id;
                  employeePosMaster.createdUserId = "";
                  employeePosMaster.createdFullName = "System Administrator";
                  employeePosMaster.createdAt = new Date();
                  employeePosMaster.lastUpdateUserId = "";
                  employeePosMaster.lastUpdateFullName = "System Administrator";
                  employeePosMaster.lastUpdatedAt = new Date();
                  await repoEmployeePosmaster.save(employeePosMaster);

                  //create employeePosition
                  item.positions.map(async (pos: any) => {
                    delete pos.id;
                    const employeePosition: EmployeePosition = Object.assign(
                      new EmployeePosition(),
                      pos,
                    );
                    employeePosition.posMasterId = employeePosMaster.id;
                    //   if (
                    //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                    //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                    //   ) {
                    //     employeePosition.positionIsSelected = false;
                    //   }
                    employeePosition.createdUserId = "";
                    employeePosition.createdFullName = "System Administrator";
                    employeePosition.createdAt = new Date();
                    employeePosition.lastUpdateUserId = "";
                    employeePosition.lastUpdateFullName = "System Administrator";
                    employeePosition.lastUpdatedAt = new Date();
                    await employeePositionRepository.save(employeePosition);
                  });
                }),
            );
            // create employeeTempPosmaster
            await Promise.all(
              _orgemployeeTempPosMaster
                .filter(
                  (x: EmployeeTempPosMaster) => x.orgChild1Id == data1Id && x.orgChild2Id == null,
                )
                .map(async (item: any) => {
                  delete item.id;
                  const employeeTempPosMaster = Object.assign(new EmployeeTempPosMaster(), item);
                  employeeTempPosMaster.positions = [];
                  // if (
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                  // ) {
                  //   employeeTempPosMaster.current_holderId = item.current_holderId;
                  // } else {
                  //   // employeeTempPosMaster.next_holderId = null;
                  //   employeeTempPosMaster.isSit = false;
                  // }
                  // if (
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                  // ) {
                  //   employeeTempPosMaster.authRoleId = item.authRoleId;
                  // } else {
                  //   employeeTempPosMaster.authRoleId = null;
                  // }
                  //   employeeTempPosMaster.current_holderId = null;
                  employeeTempPosMaster.orgRevisionId = orgRevisionDraft.id;
                  employeeTempPosMaster.orgRootId = dataId;
                  employeeTempPosMaster.orgChild1Id = data1Id;
                  employeeTempPosMaster.createdUserId = "";
                  employeeTempPosMaster.createdFullName = "System Administrator";
                  employeeTempPosMaster.createdAt = new Date();
                  employeeTempPosMaster.lastUpdateUserId = "";
                  employeeTempPosMaster.lastUpdateFullName = "System Administrator";
                  employeeTempPosMaster.lastUpdatedAt = new Date();
                  await repoEmployeeTempPosmaster.save(employeeTempPosMaster);

                  //create employeePosition
                  item.positions.map(async (pos: any) => {
                    delete pos.id;
                    const employeePosition: EmployeePosition = Object.assign(
                      new EmployeePosition(),
                      pos,
                    );
                    employeePosition.posMasterTempId = employeeTempPosMaster.id;
                    //   if (
                    //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                    //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                    //   ) {
                    //     employeePosition.positionIsSelected = false;
                    //   }
                    employeePosition.createdUserId = "";
                    employeePosition.createdFullName = "System Administrator";
                    employeePosition.createdAt = new Date();
                    employeePosition.lastUpdateUserId = "";
                    employeePosition.lastUpdateFullName = "System Administrator";
                    employeePosition.lastUpdatedAt = new Date();
                    await employeePositionRepository.save(employeePosition);
                  });
                }),
            );
            // }

            //create org
            orgChild2
              .filter((x: OrgChild2) => x.orgChild1Id == data1Id)
              .forEach(async (x: any) => {
                var data2Id = x.id;
                // if (
                //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                // ) {
                //create employeePosmaster
                await Promise.all(
                  _orgemployeePosMaster
                    .filter(
                      (x: EmployeePosMaster) => x.orgChild2Id == data2Id && x.orgChild3Id == null,
                    )
                    .map(async (item: any) => {
                      delete item.id;
                      const employeePosMaster = Object.assign(new EmployeePosMaster(), item);
                      employeePosMaster.positions = [];
                      // if (
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                      // ) {
                      //   employeePosMaster.current_holderId = item.current_holderId;
                      // } else {
                      //   // employeePosMaster.next_holderId = null;
                      //   employeePosMaster.isSit = false;
                      // }
                      // if (
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                      // ) {
                      //   employeePosMaster.authRoleId = item.authRoleId;
                      // } else {
                      //   employeePosMaster.authRoleId = null;
                      // }
                      //   employeePosMaster.current_holderId = null;
                      employeePosMaster.orgRevisionId = orgRevisionDraft.id;
                      employeePosMaster.orgRootId = dataId;
                      employeePosMaster.orgChild1Id = data1Id;
                      employeePosMaster.orgChild2Id = data2Id;
                      employeePosMaster.createdUserId = "";
                      employeePosMaster.createdFullName = "System Administrator";
                      employeePosMaster.createdAt = new Date();
                      employeePosMaster.lastUpdateUserId = "";
                      employeePosMaster.lastUpdateFullName = "System Administrator";
                      employeePosMaster.lastUpdatedAt = new Date();
                      await repoEmployeePosmaster.save(employeePosMaster);

                      //create employeePosition
                      item.positions.map(async (pos: any) => {
                        delete pos.id;
                        const employeePosition: EmployeePosition = Object.assign(
                          new EmployeePosition(),
                          pos,
                        );
                        employeePosition.posMasterId = employeePosMaster.id;
                        //   if (
                        //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                        //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                        //   ) {
                        //     employeePosition.positionIsSelected = false;
                        //   }
                        employeePosition.createdUserId = "";
                        employeePosition.createdFullName = "System Administrator";
                        employeePosition.createdAt = new Date();
                        employeePosition.lastUpdateUserId = "";
                        employeePosition.lastUpdateFullName = "System Administrator";
                        employeePosition.lastUpdatedAt = new Date();
                        await employeePositionRepository.save(employeePosition);
                      });
                    }),
                );
                // create employeeTempPosmaster
                await Promise.all(
                  _orgemployeeTempPosMaster
                    .filter(
                      (x: EmployeeTempPosMaster) =>
                        x.orgChild2Id == data2Id && x.orgChild3Id == null,
                    )
                    .map(async (item: any) => {
                      delete item.id;
                      const employeeTempPosMaster = Object.assign(
                        new EmployeeTempPosMaster(),
                        item,
                      );
                      employeeTempPosMaster.positions = [];
                      // if (
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                      // ) {
                      //   employeeTempPosMaster.current_holderId = item.current_holderId;
                      // } else {
                      //   // employeeTempPosMaster.next_holderId = null;
                      //   employeeTempPosMaster.isSit = false;
                      // }
                      // if (
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                      // ) {
                      //   employeeTempPosMaster.authRoleId = item.authRoleId;
                      // } else {
                      //   employeeTempPosMaster.authRoleId = null;
                      // }
                      //   employeeTempPosMaster.current_holderId = null;
                      employeeTempPosMaster.orgRevisionId = orgRevisionDraft.id;
                      employeeTempPosMaster.orgRootId = dataId;
                      employeeTempPosMaster.orgChild1Id = data1Id;
                      employeeTempPosMaster.orgChild2Id = data2Id;
                      employeeTempPosMaster.createdUserId = "";
                      employeeTempPosMaster.createdFullName = "System Administrator";
                      employeeTempPosMaster.createdAt = new Date();
                      employeeTempPosMaster.lastUpdateUserId = "";
                      employeeTempPosMaster.lastUpdateFullName = "System Administrator";
                      employeeTempPosMaster.lastUpdatedAt = new Date();
                      await repoEmployeeTempPosmaster.save(employeeTempPosMaster);

                      //create employeePosition
                      item.positions.map(async (pos: any) => {
                        delete pos.id;
                        const employeePosition: EmployeePosition = Object.assign(
                          new EmployeePosition(),
                          pos,
                        );
                        employeePosition.posMasterTempId = employeeTempPosMaster.id;
                        //   if (
                        //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                        //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                        //   ) {
                        //     employeePosition.positionIsSelected = false;
                        //   }
                        employeePosition.createdUserId = "";
                        employeePosition.createdFullName = "System Administrator";
                        employeePosition.createdAt = new Date();
                        employeePosition.lastUpdateUserId = "";
                        employeePosition.lastUpdateFullName = "System Administrator";
                        employeePosition.lastUpdatedAt = new Date();
                        await employeePositionRepository.save(employeePosition);
                      });
                    }),
                );
                // }

                //create org
                orgChild3
                  .filter((x: OrgChild3) => x.orgChild2Id == data2Id)
                  .forEach(async (x: any) => {
                    var data3Id = x.id;
                    // if (
                    //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                    //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                    //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                    //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                    // ) {
                    //create employeePosmaster
                    await Promise.all(
                      _orgemployeePosMaster
                        .filter(
                          (x: EmployeePosMaster) =>
                            x.orgChild3Id == data3Id && x.orgChild4Id == null,
                        )
                        .map(async (item: any) => {
                          delete item.id;
                          const employeePosMaster = Object.assign(new EmployeePosMaster(), item);
                          employeePosMaster.positions = [];
                          // if (
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                          // ) {
                          //   employeePosMaster.current_holderId = item.current_holderId;
                          // } else {
                          //   // employeePosMaster.next_holderId = null;
                          //   employeePosMaster.isSit = false;
                          // }
                          // if (
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                          // ) {
                          //   employeePosMaster.authRoleId = item.authRoleId;
                          // } else {
                          //   employeePosMaster.authRoleId = null;
                          // }
                          //   employeePosMaster.current_holderId = null;
                          employeePosMaster.orgRevisionId = orgRevisionDraft.id;
                          employeePosMaster.orgRootId = dataId;
                          employeePosMaster.orgChild1Id = data1Id;
                          employeePosMaster.orgChild2Id = data2Id;
                          employeePosMaster.orgChild3Id = data3Id;
                          employeePosMaster.createdUserId = "";
                          employeePosMaster.createdFullName = "System Administrator";
                          employeePosMaster.createdAt = new Date();
                          employeePosMaster.lastUpdateUserId = "";
                          employeePosMaster.lastUpdateFullName = "System Administrator";
                          employeePosMaster.lastUpdatedAt = new Date();
                          await repoEmployeePosmaster.save(employeePosMaster);

                          //create employeePosition
                          item.positions.map(async (pos: any) => {
                            delete pos.id;
                            const employeePosition: EmployeePosition = Object.assign(
                              new EmployeePosition(),
                              pos,
                            );
                            employeePosition.posMasterId = employeePosMaster.id;
                            //   if (
                            //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                            //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                            //   ) {
                            //     employeePosition.positionIsSelected = false;
                            //   }
                            employeePosition.createdUserId = "";
                            employeePosition.createdFullName = "System Administrator";
                            employeePosition.createdAt = new Date();
                            employeePosition.lastUpdateUserId = "";
                            employeePosition.lastUpdateFullName = "System Administrator";
                            employeePosition.lastUpdatedAt = new Date();
                            await employeePositionRepository.save(employeePosition);
                          });
                        }),
                    );
                    // create employeeTempPosmaster
                    await Promise.all(
                      _orgemployeeTempPosMaster
                        .filter(
                          (x: EmployeeTempPosMaster) =>
                            x.orgChild3Id == data3Id && x.orgChild4Id == null,
                        )
                        .map(async (item: any) => {
                          delete item.id;
                          const employeeTempPosMaster = Object.assign(
                            new EmployeeTempPosMaster(),
                            item,
                          );
                          employeeTempPosMaster.positions = [];
                          // if (
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                          // ) {
                          //   employeeTempPosMaster.current_holderId = item.current_holderId;
                          // } else {
                          //   // employeeTempPosMaster.next_holderId = null;
                          //   employeeTempPosMaster.isSit = false;
                          // }
                          // if (
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                          // ) {
                          //   employeeTempPosMaster.authRoleId = item.authRoleId;
                          // } else {
                          //   employeeTempPosMaster.authRoleId = null;
                          // }
                          //   employeeTempPosMaster.current_holderId = null;
                          employeeTempPosMaster.orgRevisionId = orgRevisionDraft.id;
                          employeeTempPosMaster.orgRootId = dataId;
                          employeeTempPosMaster.orgChild1Id = data1Id;
                          employeeTempPosMaster.orgChild2Id = data2Id;
                          employeeTempPosMaster.orgChild3Id = data3Id;
                          employeeTempPosMaster.createdUserId = "";
                          employeeTempPosMaster.createdFullName = "System Administrator";
                          employeeTempPosMaster.createdAt = new Date();
                          employeeTempPosMaster.lastUpdateUserId = "";
                          employeeTempPosMaster.lastUpdateFullName = "System Administrator";
                          employeeTempPosMaster.lastUpdatedAt = new Date();
                          await repoEmployeeTempPosmaster.save(employeeTempPosMaster);

                          //create employeePosition
                          item.positions.map(async (pos: any) => {
                            delete pos.id;
                            const employeePosition: EmployeePosition = Object.assign(
                              new EmployeePosition(),
                              pos,
                            );
                            employeePosition.posMasterTempId = employeeTempPosMaster.id;
                            //   if (
                            //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                            //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                            //   ) {
                            //     employeePosition.positionIsSelected = false;
                            //   }
                            employeePosition.createdUserId = "";
                            employeePosition.createdFullName = "System Administrator";
                            employeePosition.createdAt = new Date();
                            employeePosition.lastUpdateUserId = "";
                            employeePosition.lastUpdateFullName = "System Administrator";
                            employeePosition.lastUpdatedAt = new Date();
                            await employeePositionRepository.save(employeePosition);
                          });
                        }),
                    );
                    // }

                    //create org
                    orgChild4
                      .filter((x: OrgChild4) => x.orgChild3Id == data3Id)
                      .forEach(async (x: any) => {
                        var data4Id = x.id;
                        // if (
                        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                        // ) {
                        //create employeePosmaster
                        await Promise.all(
                          _orgemployeePosMaster
                            .filter((x: EmployeePosMaster) => x.orgChild4Id == data4Id)
                            .map(async (item: any) => {
                              delete item.id;
                              const employeePosMaster = Object.assign(
                                new EmployeePosMaster(),
                                item,
                              );
                              employeePosMaster.positions = [];
                              // if (
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                              // ) {
                              //   employeePosMaster.current_holderId = item.current_holderId;
                              // } else {
                              //   // employeePosMaster.next_holderId = null;
                              //   employeePosMaster.isSit = false;
                              // }
                              // if (
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                              // ) {
                              //   employeePosMaster.authRoleId = item.authRoleId;
                              // } else {
                              //   employeePosMaster.authRoleId = null;
                              // }
                              //   employeePosMaster.current_holderId = null;
                              employeePosMaster.orgRevisionId = orgRevisionDraft.id;
                              employeePosMaster.orgRootId = dataId;
                              employeePosMaster.orgChild1Id = data1Id;
                              employeePosMaster.orgChild2Id = data2Id;
                              employeePosMaster.orgChild3Id = data3Id;
                              employeePosMaster.orgChild4Id = data4Id;
                              employeePosMaster.createdUserId = "";
                              employeePosMaster.createdFullName = "System Administrator";
                              employeePosMaster.createdAt = new Date();
                              employeePosMaster.lastUpdateUserId = "";
                              employeePosMaster.lastUpdateFullName = "System Administrator";
                              employeePosMaster.lastUpdatedAt = new Date();
                              await repoEmployeePosmaster.save(employeePosMaster);

                              //create employeePosition
                              item.positions.map(async (pos: any) => {
                                delete pos.id;
                                const employeePosition: EmployeePosition = Object.assign(
                                  new EmployeePosition(),
                                  pos,
                                );
                                employeePosition.posMasterId = employeePosMaster.id;
                                //   if (
                                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                                //   ) {
                                //     employeePosition.positionIsSelected = false;
                                //   }
                                employeePosition.createdUserId = "";
                                employeePosition.createdFullName = "System Administrator";
                                employeePosition.createdAt = new Date();
                                employeePosition.lastUpdateUserId = "";
                                employeePosition.lastUpdateFullName = "System Administrator";
                                employeePosition.lastUpdatedAt = new Date();
                                await employeePositionRepository.save(employeePosition);
                              });
                            }),
                        );
                        //create employeeTempPosmaster
                        await Promise.all(
                          _orgemployeeTempPosMaster
                            .filter((x: EmployeeTempPosMaster) => x.orgChild4Id == data4Id)
                            .map(async (item: any) => {
                              delete item.id;
                              const employeeTempPosMaster = Object.assign(
                                new EmployeeTempPosMaster(),
                                item,
                              );
                              employeeTempPosMaster.positions = [];
                              // if (
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                              // ) {
                              //   employeeTempPosMaster.current_holderId = item.current_holderId;
                              // } else {
                              //   // employeeTempPosMaster.next_holderId = null;
                              //   employeeTempPosMaster.isSit = false;
                              // }
                              // if (
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                              // ) {
                              //   employeeTempPosMaster.authRoleId = item.authRoleId;
                              // } else {
                              //   employeeTempPosMaster.authRoleId = null;
                              // }
                              //   employeeTempPosMaster.current_holderId = null;
                              employeeTempPosMaster.orgRevisionId = orgRevisionDraft.id;
                              employeeTempPosMaster.orgRootId = dataId;
                              employeeTempPosMaster.orgChild1Id = data1Id;
                              employeeTempPosMaster.orgChild2Id = data2Id;
                              employeeTempPosMaster.orgChild3Id = data3Id;
                              employeeTempPosMaster.orgChild4Id = data4Id;
                              employeeTempPosMaster.createdUserId = "";
                              employeeTempPosMaster.createdFullName = "System Administrator";
                              employeeTempPosMaster.createdAt = new Date();
                              employeeTempPosMaster.lastUpdateUserId = "";
                              employeeTempPosMaster.lastUpdateFullName = "System Administrator";
                              employeeTempPosMaster.lastUpdatedAt = new Date();
                              await repoEmployeeTempPosmaster.save(employeeTempPosMaster);

                              //create employeePosition
                              item.positions.map(async (pos: any) => {
                                delete pos.id;
                                const employeePosition: EmployeePosition = Object.assign(
                                  new EmployeePosition(),
                                  pos,
                                );
                                employeePosition.posMasterTempId = employeeTempPosMaster.id;
                                //   if (
                                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                                //   ) {
                                //     employeePosition.positionIsSelected = false;
                                //   }
                                employeePosition.createdUserId = "";
                                employeePosition.createdFullName = "System Administrator";
                                employeePosition.createdAt = new Date();
                                employeePosition.lastUpdateUserId = "";
                                employeePosition.lastUpdateFullName = "System Administrator";
                                employeePosition.lastUpdatedAt = new Date();
                                await employeePositionRepository.save(employeePosition);
                              });
                            }),
                        );
                        // }
                      });
                  });
              });
          });
      });
      // }

      const employeePosMaster = await repoEmployeePosmaster.find({
        where: { orgRevisionId: orgRevisionDraft.id },
        relations: ["positions", "positions.posLevel", "positions.posType"],
      });
      for (const item of employeePosMaster) {
        if (item.next_holderId != null) {
          const profile = await repoProfileEmployee.findOne({
            where: { id: item.next_holderId == null ? "" : item.next_holderId },
          });
          const position = await item.positions.find((x) => x.positionIsSelected == true);
          const _null: any = null;
          if (profile != null) {
            profile.posLevelId = position?.posLevelId ?? _null;
            profile.posTypeId = position?.posTypeId ?? _null;
            profile.position = position?.positionName ?? _null;
            await repoProfileEmployee.save(profile);
          }
        }
        // item.current_holderId = item.next_holderId;
        // item.next_holderId = null;
        item.lastUpdateUserId = lastUpdateUserId;
        item.lastUpdateFullName = lastUpdateFullName;
        item.lastUpdatedAt = lastUpdatedAt;
        await repoEmployeePosmaster.save(item).catch((e) => console.log(e));
      }
      const employeeTempPosMaster = await repoEmployeeTempPosmaster.find({
        where: { orgRevisionId: orgRevisionDraft.id },
        relations: ["positions", "positions.posLevel", "positions.posType"],
      });
      for (const item of employeeTempPosMaster) {
        if (item.next_holderId != null) {
          const profile = await repoProfileEmployee.findOne({
            where: { id: item.next_holderId == null ? "" : item.next_holderId },
          });
          const position = await item.positions.find((x) => x.positionIsSelected == true);
          const _null: any = null;
          if (profile != null) {
            profile.posLevelId = position?.posLevelId ?? _null;
            profile.posTypeId = position?.posTypeId ?? _null;
            profile.position = position?.positionName ?? _null;
            await repoProfileEmployee.save(profile);
          }
        }
        // item.current_holderId = item.next_holderId;
        // item.next_holderId = null;
        item.lastUpdateUserId = lastUpdateUserId;
        item.lastUpdateFullName = lastUpdateFullName;
        item.lastUpdatedAt = lastUpdatedAt;
        await repoEmployeeTempPosmaster.save(item).catch((e) => console.log(e));
      }
    }
    console.log("[AMQ] Excecute Organization Success");
    return true;
  } catch (error) {
    console.error(error);
    return false;
  }
}

async function handler_org_draft(msg: amqp.ConsumeMessage): Promise<boolean> {
  const { data, token, user } = JSON.parse(msg.content.toString());
  const { requestBody, request, revision } = data;
  const posMasterRepository = AppDataSource.getRepository(PosMaster);
  const positionRepository = AppDataSource.getRepository(Position);
  const employeePosMasterRepository = AppDataSource.getRepository(EmployeePosMaster);
  const employeeTempPosMasterRepository = AppDataSource.getRepository(EmployeeTempPosMaster);
  const posMasterAssignRepository = AppDataSource.getRepository(PosMasterAssign);
  const posMasterActRepository = AppDataSource.getRepository(PosMasterAct);
  const permissionOrgRepository = AppDataSource.getRepository(PermissionOrg);
  const employeePositionRepository = AppDataSource.getRepository(EmployeePosition);
  const orgRevisionRepository = AppDataSource.getRepository(OrgRevision);
  const orgRootRepository = AppDataSource.getRepository(OrgRoot);
  const child1Repository = AppDataSource.getRepository(OrgChild1);
  const child2Repository = AppDataSource.getRepository(OrgChild2);
  const child3Repository = AppDataSource.getRepository(OrgChild3);
  const child4Repository = AppDataSource.getRepository(OrgChild4);

  try {   
        //cone tree
        if (
          requestBody.typeDraft.toUpperCase() == "ORG" ||
          requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
          requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
          requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
          requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
        ) {
          //cone by revisionId
          if (requestBody.orgRevisionId == null)
            throw new HttpError(HttpStatusCode.NOT_FOUND, "not found.");
          const _revision = await orgRevisionRepository.findOne({
            where: { id: requestBody.orgRevisionId },
          });
          if (!_revision) throw new HttpError(HttpStatusCode.NOT_FOUND, "not found.");
    
          //หา dna tree ถ้าไม่มีให้เอาตัวเองเป็น dna
          const orgRoot = await orgRootRepository.find({
            where: { orgRevisionId: requestBody.orgRevisionId },
            order:{orgRootOrder:"ASC"}
          });
          let _orgRoot: any = orgRoot.map((x) => ({
            ...x,
            ancestorDNA:
              x.ancestorDNA == null || x.ancestorDNA == "00000000-0000-0000-0000-000000000000"
                ? x.id
                : x.ancestorDNA,
          }));
          await orgRootRepository.save(_orgRoot);
    
          const orgChild1 = await child1Repository.find({
            where: { orgRevisionId: requestBody.orgRevisionId },
            order:{orgChild1Order:"ASC"}
          });
          let _orgChild1: any = orgChild1.map((x) => ({
            ...x,
            ancestorDNA:
              x.ancestorDNA == null || x.ancestorDNA == "00000000-0000-0000-0000-000000000000"
                ? x.id
                : x.ancestorDNA,
          }));
          await child1Repository.save(_orgChild1);
    
          const orgChild2 = await child2Repository.find({
            where: { orgRevisionId: requestBody.orgRevisionId },
            order:{orgChild2Order:"ASC"}
          });
          let _orgChild2: any = orgChild2.map((x) => ({
            ...x,
            ancestorDNA:
              x.ancestorDNA == null || x.ancestorDNA == "00000000-0000-0000-0000-000000000000"
                ? x.id
                : x.ancestorDNA,
          }));
          await child2Repository.save(_orgChild2);
    
          const orgChild3 = await child3Repository.find({
            where: { orgRevisionId: requestBody.orgRevisionId },
            order:{orgChild3Order:"ASC"}
          });
          let _orgChild3: any = orgChild3.map((x) => ({
            ...x,
            ancestorDNA:
              x.ancestorDNA == null || x.ancestorDNA == "00000000-0000-0000-0000-000000000000"
                ? x.id
                : x.ancestorDNA,
          }));
          await child3Repository.save(_orgChild3);
    
          const orgChild4 = await child4Repository.find({
            where: { orgRevisionId: requestBody.orgRevisionId },
            order:{orgChild4Order:"ASC"}
          });
          let _orgChild4: any = orgChild4.map((x) => ({
            ...x,
            ancestorDNA:
              x.ancestorDNA == null || x.ancestorDNA == "00000000-0000-0000-0000-000000000000"
                ? x.id
                : x.ancestorDNA,
          }));
          await child4Repository.save(_orgChild4);
    
          //หา dna posmaster ถ้าไม่มีให้เอาตัวเองเป็น dna
          const orgPosMaster = await posMasterRepository.find({
            where: { orgRevisionId: requestBody.orgRevisionId },
            relations: ["positions", "posMasterAssigns"],
          });
    
          let _orgPosMaster: PosMaster[] = [];
          if (
            requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
            requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
            requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
            requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
          ) {
            _orgPosMaster = orgPosMaster
              .filter(
                (x) => x.ancestorDNA == null || x.ancestorDNA == "00000000-0000-0000-0000-000000000000",
              )
              .map((x) => ({
                ...x,
                ancestorDNA:
                  x.ancestorDNA == null || x.ancestorDNA == "00000000-0000-0000-0000-000000000000"
                    ? x.id
                    : x.ancestorDNA,
              }));
            await posMasterRepository.save(_orgPosMaster);
          }
          // Create org
          for await (const x0 of _orgRoot) {
            var dataId = x0.id;
            console.log(`ch0 ${x0.orgRootOrder}`)
            console.log(dataId)
            delete x0.id;
            const data = Object.assign(new OrgRoot(), x0);
            data.orgRevisionId = revision.id;
            data.createdUserId = request.sub;
            data.createdFullName = request.name;
            data.createdAt = new Date();
            data.lastUpdateUserId = request.sub;
            data.lastUpdateFullName = request.name;
            data.lastUpdatedAt = new Date();
            await orgRootRepository.save(data);
    
            const orgTypes = new Set([
              "ORG_POSITION",
              "ORG_POSITION_PERSON",
              "ORG_POSITION_ROLE",
              "ORG_POSITION_PERSON_ROLE",
            ]);
    
            if (orgTypes.has(requestBody.typeDraft.toUpperCase())) {
              // Create posMaster
              for await (const item of orgPosMaster.filter(
                (x: PosMaster) => x.orgRootId == dataId && x.orgChild1Id == null,
              ) as any) {
                delete item.id;
                const posMaster: any = Object.assign(new PosMaster(), item);
                posMaster.positions = [];
    
                if (
                  ["ORG_POSITION_PERSON", "ORG_POSITION_PERSON_ROLE"].includes(
                    requestBody.typeDraft.toUpperCase(),
                  )
                ) {
                  posMaster.next_holderId = item.current_holderId;
                } else {
                  posMaster.next_holderId = null;
                  posMaster.isSit = false;
                }
    
                if (
                  ["ORG_POSITION_ROLE", "ORG_POSITION_PERSON_ROLE"].includes(
                    requestBody.typeDraft.toUpperCase(),
                  )
                ) {
                  posMaster.authRoleId = item.authRoleId;
                } else {
                  posMaster.authRoleId = null;
                }
    
                posMaster.current_holderId = null;
                posMaster.orgRevisionId = revision.id;
                posMaster.orgRootId = data.id;
                posMaster.createdUserId = request.sub;
                posMaster.createdFullName = request.name;
                posMaster.createdAt = new Date();
                posMaster.lastUpdateUserId = request.sub;
                posMaster.lastUpdateFullName = request.name;
                posMaster.lastUpdatedAt = new Date();
                await posMasterRepository.save(posMaster);
    
                // Copy assignments
                item.posMasterAssigns = item.posMasterAssigns.map(
                  ({ id, ...rest }: PosMasterAssign) => ({
                    ...rest,
                    posMasterId: posMaster.id,
                  }),
                );
                posMaster.posMasterAssigns = item.posMasterAssigns;
    
                // Create positions
                for await (const pos of item.positions) {
                  delete pos.id;
                  const position = Object.assign(new Position(), pos);
                  position.posMasterId = posMaster.id;
    
                  if (
                    ["ORG_POSITION", "ORG_POSITION_ROLE"].includes(requestBody.typeDraft.toUpperCase())
                  ) {
                    position.positionIsSelected = false;
                  }
    
                  position.createdUserId = request.sub;
                  position.createdFullName = request.name;
                  position.createdAt = new Date();
                  position.lastUpdateUserId = request.sub;
                  position.lastUpdateFullName = request.name;
                  position.lastUpdatedAt = new Date();
                  await positionRepository.save(position);
                }
              }
            }
    
            // Create orgChild1
            for await (const x1 of _orgChild1.filter((x: OrgChild1) => x.orgRootId == dataId)) {
              var data1Id = x1.id;
              console.log(`ch1 ${x1.orgChild1Order}`)
              console.log(data1Id)
              delete x1.id;
              const data1 = Object.assign(new OrgChild1(), x1);
              data1.orgRootId = data.id;
              data1.orgRevisionId = revision.id;
              data1.createdUserId = request.sub;
              data1.createdFullName = request.name;
              data1.createdAt = new Date();
              data1.lastUpdateUserId = request.sub;
              data1.lastUpdateFullName = request.name;
              data1.lastUpdatedAt = new Date();
              await child1Repository.save(data1);
    
              if (orgTypes.has(requestBody.typeDraft.toUpperCase())) {
                // Create posMaster
                for await (const item of orgPosMaster.filter(
                  (x: PosMaster) => x.orgChild1Id == data1Id && x.orgChild2Id == null,
                ) as any) {
                  delete item.id;
                  const posMaster = Object.assign(new PosMaster(), item);
                  posMaster.positions = [];
    
                  if (
                    ["ORG_POSITION_PERSON", "ORG_POSITION_PERSON_ROLE"].includes(
                      requestBody.typeDraft.toUpperCase(),
                    )
                  ) {
                    posMaster.next_holderId = item.current_holderId;
                  } else {
                    posMaster.next_holderId = null;
                    posMaster.isSit = false;
                  }
    
                  if (
                    ["ORG_POSITION_ROLE", "ORG_POSITION_PERSON_ROLE"].includes(
                      requestBody.typeDraft.toUpperCase(),
                    )
                  ) {
                    posMaster.authRoleId = item.authRoleId;
                  } else {
                    posMaster.authRoleId = null;
                  }
    
                  posMaster.current_holderId = null;
                  posMaster.orgRevisionId = revision.id;
                  posMaster.orgRootId = data.id;
                  posMaster.orgChild1Id = data1.id;
                  posMaster.createdUserId = request.sub;
                  posMaster.createdFullName = request.name;
                  posMaster.createdAt = new Date();
                  posMaster.lastUpdateUserId = request.sub;
                  posMaster.lastUpdateFullName = request.name;
                  posMaster.lastUpdatedAt = new Date();
                  await posMasterRepository.save(posMaster);
    
                  // Copy assignments
                  item.posMasterAssigns = item.posMasterAssigns.map(
                    ({ id, ...rest }: PosMasterAssign) => ({
                      ...rest,
                      posMasterId: posMaster.id,
                    }),
                  );
                  posMaster.posMasterAssigns = item.posMasterAssigns;
    
                  // Create positions
                  for await (const pos of item.positions) {
                    delete pos.id;
                    const position = Object.assign(new Position(), pos);
                    position.posMasterId = posMaster.id;
    
                    if (
                      ["ORG_POSITION", "ORG_POSITION_ROLE"].includes(
                        requestBody.typeDraft.toUpperCase(),
                      )
                    ) {
                      position.positionIsSelected = false;
                    }
    
                    position.createdUserId = request.sub;
                    position.createdFullName = request.name;
                    position.createdAt = new Date();
                    position.lastUpdateUserId = request.sub;
                    position.lastUpdateFullName = request.name;
                    position.lastUpdatedAt = new Date();
                    await positionRepository.save(position);
                  }
                }
              }
              for await (const x2 of _orgChild2.filter((x: OrgChild2) => x.orgChild1Id == data1Id)) {
                var data2Id = x2.id;
                console.log(`ch2 ${x2.orgChild2Order}`)
                console.log(data2Id)
                delete x2.id;
                const data2 = Object.assign(new OrgChild2(), x2);
                data2.orgChild1Id = data1.id;
                data2.orgRootId = data.id;
                data2.orgRevisionId = revision.id;
                data2.createdUserId = request.sub;
                data2.createdFullName = request.name;
                data2.createdAt = new Date();
                data2.lastUpdateUserId = request.sub;
                data2.lastUpdateFullName = request.name;
                data2.lastUpdatedAt = new Date();
                await child2Repository.save(data2);
    
                if (orgTypes.has(requestBody.typeDraft.toUpperCase())) {
                  // Create posMaster
                  for await (const item of orgPosMaster.filter(
                    (x: PosMaster) => x.orgChild2Id == data2Id && x.orgChild3Id == null,
                  ) as any) {
                    delete item.id;
                    const posMaster = Object.assign(new PosMaster(), item);
                    posMaster.positions = [];
    
                    if (
                      ["ORG_POSITION_PERSON", "ORG_POSITION_PERSON_ROLE"].includes(
                        requestBody.typeDraft.toUpperCase(),
                      )
                    ) {
                      posMaster.next_holderId = item.current_holderId;
                    } else {
                      posMaster.next_holderId = null;
                      posMaster.isSit = false;
                    }
    
                    if (
                      ["ORG_POSITION_ROLE", "ORG_POSITION_PERSON_ROLE"].includes(
                        requestBody.typeDraft.toUpperCase(),
                      )
                    ) {
                      posMaster.authRoleId = item.authRoleId;
                    } else {
                      posMaster.authRoleId = null;
                    }
    
                    posMaster.current_holderId = null;
                    posMaster.orgRevisionId = revision.id;
                    posMaster.orgRootId = data.id;
                    posMaster.orgChild1Id = data1.id;
                    posMaster.orgChild2Id = data2.id;
                    posMaster.createdUserId = request.sub;
                    posMaster.createdFullName = request.name;
                    posMaster.createdAt = new Date();
                    posMaster.lastUpdateUserId = request.sub;
                    posMaster.lastUpdateFullName = request.name;
                    posMaster.lastUpdatedAt = new Date();
                    await posMasterRepository.save(posMaster);
    
                    // Copy assignments
                    posMaster.posMasterAssigns = item.posMasterAssigns.map(
                      ({ id, ...rest }: PosMasterAssign) => ({
                        ...rest,
                        posMasterId: posMaster.id,
                      }),
                    );
    
                    // Create positions
                    for await (const pos of item.positions) {
                      delete pos.id;
                      const position = Object.assign(new Position(), pos);
                      position.posMasterId = posMaster.id;
                      if (
                        ["ORG_POSITION", "ORG_POSITION_ROLE"].includes(
                          requestBody.typeDraft.toUpperCase(),
                        )
                      ) {
                        position.positionIsSelected = false;
                      }
                      position.createdUserId = request.sub;
                      position.createdFullName = request.name;
                      position.createdAt = new Date();
                      position.lastUpdateUserId = request.sub;
                      position.lastUpdateFullName = request.name;
                      position.lastUpdatedAt = new Date();
                      await positionRepository.save(position);
                    }
                  }
                }
    
                // Create org
                for await (const x3 of _orgChild3.filter((x: OrgChild3) => x.orgChild2Id == data2Id)) {
                  var data3Id = x3.id;
                  console.log(`ch3 ${x3.orgChild3Order}`)
                  console.log(data3Id)
                  delete x3.id;
                  const data3 = Object.assign(new OrgChild3(), x3);
                  data3.orgChild2Id = data2.id;
                  data3.orgChild1Id = data1.id;
                  data3.orgRootId = data.id;
                  data3.orgRevisionId = revision.id;
                  data3.createdUserId = request.sub;
                  data3.createdFullName = request.name;
                  data3.createdAt = new Date();
                  data3.lastUpdateUserId = request.sub;
                  data3.lastUpdateFullName = request.name;
                  data3.lastUpdatedAt = new Date();
                  await child3Repository.save(data3);
    
                  if (orgTypes.has(requestBody.typeDraft.toUpperCase())) {
                    // Create posMaster
                    for await (const item of orgPosMaster.filter(
                      (x: PosMaster) => x.orgChild3Id == data3Id && x.orgChild4Id == null,
                    ) as any) {
                      delete item.id;
                      const posMaster = Object.assign(new PosMaster(), item);
                      posMaster.positions = [];
    
                      if (
                        ["ORG_POSITION_PERSON", "ORG_POSITION_PERSON_ROLE"].includes(
                          requestBody.typeDraft.toUpperCase(),
                        )
                      ) {
                        posMaster.next_holderId = item.current_holderId;
                      } else {
                        posMaster.next_holderId = null;
                        posMaster.isSit = false;
                      }
    
                      if (
                        ["ORG_POSITION_ROLE", "ORG_POSITION_PERSON_ROLE"].includes(
                          requestBody.typeDraft.toUpperCase(),
                        )
                      ) {
                        posMaster.authRoleId = item.authRoleId;
                      } else {
                        posMaster.authRoleId = null;
                      }
    
                      posMaster.current_holderId = null;
                      posMaster.orgRevisionId = revision.id;
                      posMaster.orgRootId = data.id;
                      posMaster.orgChild1Id = data1.id;
                      posMaster.orgChild2Id = data2.id;
                      posMaster.orgChild3Id = data3.id;
                      posMaster.createdUserId = request.sub;
                      posMaster.createdFullName = request.name;
                      posMaster.createdAt = new Date();
                      posMaster.lastUpdateUserId = request.sub;
                      posMaster.lastUpdateFullName = request.name;
                      posMaster.lastUpdatedAt = new Date();
                      await posMasterRepository.save(posMaster);
    
                      // Copy assignments
                      posMaster.posMasterAssigns = item.posMasterAssigns.map(
                        ({ id, ...rest }: PosMasterAssign) => ({
                          ...rest,
                          posMasterId: posMaster.id,
                        }),
                      );
    
                      // Create positions
                      for await (const pos of item.positions) {
                        delete pos.id;
                        const position = Object.assign(new Position(), pos);
                        position.posMasterId = posMaster.id;
                        if (
                          ["ORG_POSITION", "ORG_POSITION_ROLE"].includes(
                            requestBody.typeDraft.toUpperCase(),
                          )
                        ) {
                          position.positionIsSelected = false;
                        }
                        position.createdUserId = request.sub;
                        position.createdFullName = request.name;
                        position.createdAt = new Date();
                        position.lastUpdateUserId = request.sub;
                        position.lastUpdateFullName = request.name;
                        position.lastUpdatedAt = new Date();
                        await positionRepository.save(position);
                      }
                    }
                  }
                  // Create org
                  for await (const x4 of _orgChild4.filter(
                    (x: OrgChild4) => x.orgChild3Id == data3Id,
                  )) {
                    var data4Id = x4.id;
                    console.log(`ch4 ${x4.orgChild4Order}`)
                    console.log(data4Id)
                    delete x4.id;
                    const data4 = Object.assign(new OrgChild4(), x4);
                    data4.orgChild3Id = data3.id;
                    data4.orgChild2Id = data2.id;
                    data4.orgChild1Id = data1.id;
                    data4.orgRootId = data.id;
                    data4.orgRevisionId = revision.id;
                    data4.createdUserId = request.sub;
                    data4.createdFullName = request.name;
                    data4.createdAt = new Date();
                    data4.lastUpdateUserId = request.sub;
                    data4.lastUpdateFullName = request.name;
                    data4.lastUpdatedAt = new Date();
                    await child4Repository.save(data4);
    
                    if (orgTypes.has(requestBody.typeDraft.toUpperCase())) {
                      // Create posMaster
                      for await (const item of orgPosMaster.filter(
                        (x: PosMaster) => x.orgChild4Id == data4Id,
                      ) as any) {
                        delete item.id;
                        const posMaster = Object.assign(new PosMaster(), item);
                        posMaster.positions = [];
    
                        if (
                          ["ORG_POSITION_PERSON", "ORG_POSITION_PERSON_ROLE"].includes(
                            requestBody.typeDraft.toUpperCase(),
                          )
                        ) {
                          posMaster.next_holderId = item.current_holderId;
                        } else {
                          posMaster.next_holderId = null;
                          posMaster.isSit = false;
                        }
    
                        if (
                          ["ORG_POSITION_ROLE", "ORG_POSITION_PERSON_ROLE"].includes(
                            requestBody.typeDraft.toUpperCase(),
                          )
                        ) {
                          posMaster.authRoleId = item.authRoleId;
                        } else {
                          posMaster.authRoleId = null;
                        }
    
                        posMaster.current_holderId = null;
                        posMaster.orgRevisionId = revision.id;
                        posMaster.orgRootId = data.id;
                        posMaster.orgChild1Id = data1.id;
                        posMaster.orgChild2Id = data2.id;
                        posMaster.orgChild3Id = data3.id;
                        posMaster.orgChild4Id = data4.id;
                        posMaster.createdUserId = request.sub;
                        posMaster.createdFullName = request.name;
                        posMaster.createdAt = new Date();
                        posMaster.lastUpdateUserId = request.sub;
                        posMaster.lastUpdateFullName = request.name;
                        posMaster.lastUpdatedAt = new Date();
                        await posMasterRepository.save(posMaster);
    
                        // Copy assignments
                        posMaster.posMasterAssigns = item.posMasterAssigns.map(
                          ({ id, ...rest }: PosMasterAssign) => ({
                            ...rest,
                            posMasterId: posMaster.id,
                          }),
                        );
    
                        // Create positions
                        for await (const pos of item.positions) {
                          delete pos.id;
                          const position = Object.assign(new Position(), pos);
                          position.posMasterId = posMaster.id;
                          if (
                            ["ORG_POSITION", "ORG_POSITION_ROLE"].includes(
                              requestBody.typeDraft.toUpperCase(),
                            )
                          ) {
                            position.positionIsSelected = false;
                          }
                          position.createdUserId = request.sub;
                          position.createdFullName = request.name;
                          position.createdAt = new Date();
                          position.lastUpdateUserId = request.sub;
                          position.lastUpdateFullName = request.name;
                          position.lastUpdatedAt = new Date();
                          await positionRepository.save(position);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
    
        const _orgRevisions = await orgRevisionRepository.find({
          where: [{ orgRevisionIsDraft: true, id: Not(revision.id) }],
        });
        const _roots = await orgRootRepository.find({
          where: [{ orgRevisionId: In(_orgRevisions.map((x) => x.id)) }],
        });
        const _posMasters = await posMasterRepository.find({
          where: [{ orgRevisionId: In(_orgRevisions.map((x) => x.id)) }],
        });
        const _employeePosMasters = await employeePosMasterRepository.find({
          where: [{ orgRevisionId: In(_orgRevisions.map((x) => x.id)) }],
        });
        const _employeeTempPosMasters = await employeeTempPosMasterRepository.find({
          where: [{ orgRevisionId: In(_orgRevisions.map((x) => x.id)) }],
        });
        await positionRepository.delete({ posMasterId: In(_posMasters.map((x) => x.id)) });
        await employeePositionRepository.delete({
          posMasterId: In(_employeePosMasters.map((x) => x.id)),
        });
        await employeePositionRepository.delete({
          posMasterTempId: In(_employeeTempPosMasters.map((x) => x.id)),
        });
        await posMasterAssignRepository.delete({ posMasterId: In(_posMasters.map((x) => x.id)) });
        await posMasterActRepository.delete({ posMasterId: In(_posMasters.map((x) => x.id)) });
        await posMasterActRepository.delete({
          posMasterChildId: In(_posMasters.map((x) => x.id)),
        });
        await posMasterRepository.remove(_posMasters);
        await employeePosMasterRepository.remove(_employeePosMasters);
        await employeeTempPosMasterRepository.remove(_employeeTempPosMasters);
        await child4Repository.delete({ orgRevisionId: In(_orgRevisions.map((x) => x.id)) });
        await child3Repository.delete({ orgRevisionId: In(_orgRevisions.map((x) => x.id)) });
        await child2Repository.delete({ orgRevisionId: In(_orgRevisions.map((x) => x.id)) });
        await child1Repository.delete({ orgRevisionId: In(_orgRevisions.map((x) => x.id)) });
        await permissionOrgRepository.delete({
          orgRootId: In(_roots.map((x) => x.id)),
        });
        await orgRootRepository.delete({ orgRevisionId: In(_orgRevisions.map((x) => x.id)) });
        await orgRevisionRepository.remove(_orgRevisions);
        
    console.log("[AMQ] Create Draft Success");
    return true;
  } catch (error) {
    console.error(error);
    return false;
  }
}