Untitled

var fs = require('fs');
const axios = require('axios').default;

const apiOcean = 'https://homologacao-api-ocean.app.trinus.co';
const apiOceanFiles = 'https://homol-ms-ocean-files.app.trinus.co';
const apiOceanForms = 'https://homol-ms-ocean-forms.app.trinus.co';
const apiOceanCustomers = 'https://homol-ms-ocean-customers.app.trinus.co';
const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6NTgsImVtYWlsIjoiam9uYXRoYW4uZm9uc2VjYUB0cmludXNjby5jb20uYnIiLCJyYW5kb21pemUiOjAuNTg5NDc1NzM5MTk1Mzc1MywiaWF0IjoxNjg5MzU5OTYxLCJleHAiOjE2ODk0NDYzNjF9.QK0JG26gAI6qTFF-CPgEOl5uP5dq_Zyee0v9btPOPbI';

const pBoardId = 216;
const pPriority = 1;
const pColumnId = 1572;
const pItemTypeId = 457;

const pWorkItemModelId = 195314;

const createWorkItem = async (qtd) => {
  try {
    try {
      return await axios({
        url: `${apiOcean}/api/v1/workItemCreate`,
        method: 'post',
        data: {
          name: `Item de trabalho ${qtd}`,
          columnId: pColumnId,
          priority: pPriority,
          boardId: pBoardId,
          position: 0,
          itemTypeId: pItemTypeId,
          recordType: "WIT",
          addYourselfResponsible: "N"
        },
        headers: { Authorization: token },
        maxContentLength: Infinity,
        maxBodyLength: Infinity,
      });
    } catch (error) {
      return error;
    }
  } catch (error) {
    return error;
  }
};

const directoriesWorkItem = async (
  workItemId,
  boardId,
  name,
) => {
  try {
    try {
      return await axios({
        url: `${apiOceanFiles}/ocean/ms-ocean-files/v1/directories/work-item/${workItemId}/board-id/${boardId}?originBoardId=undefined`,
        method: 'post',
        data: {
          workItemHierarchy:[{
            workItemId: workItemId,
            name: name,
            boardId: [boardId],
            children:[]
          }]
        },
        headers: { Authorization: token },
        maxContentLength: Infinity,
        maxBodyLength: Infinity,
      });
    } catch (error) {
      return error;
    }
  } catch (error) {
    return error;
  }
};

const updateDirectory = async (
  shareTaskId,
  directoryId,
) => {
  try {
    try {
      return await axios({
        method: 'put',
        url: `${apiOcean}/api/v1/share-task/update-directory`,
        data: {
          shareTaskId: shareTaskId,
          directoryId: directoryId,
        },
        headers: { Authorization: token },
        maxContentLength: Infinity,
        maxBodyLength: Infinity,
      });
    } catch (error) {
      return error;
    }
  } catch (error) {
    return error;
  }
};

const applyModelWorkItem = async (
  shareTaskId,
  workItemModelId
) => {
  try {
    try {
      return await axios({
        url: `${apiOcean}/api/v1/model/ApplyModel`,
        method: 'post',
        data: {
          shareTaskId: shareTaskId,
          workItemModelId: workItemModelId,
        },
        headers: { Authorization: token },
        maxContentLength: Infinity,
        maxBodyLength: Infinity,
      });
    } catch (error) {
      return error;
    }
  } catch (error) {
    return error;
  }
};

const applyModelOceanForms = async (
  workItemId,
  workItemModelId,
  itemTypeId,
) => {
  try {
    try {
      return await axios({
        url: `${apiOceanForms}/ocean/ms-ocean-forms/v1/work-item/apply-work-item-template`,
        method: 'post',
        data: {
          workItems:
          [{
            workItemId: workItemId,
            workItemModelId: workItemModelId,
            itemTypeId: itemTypeId
          }]
        },
        headers: { Authorization: token },
        maxContentLength: Infinity,
        maxBodyLength: Infinity,
      });
    } catch (error) {
      return error;
    }
  } catch (error) {
    return error;
  }
};

const bindCustomerToBoard = async (
  boardId,
  personIds
) => {
  try {
    try {
      return await axios({
        url: `${apiOceanCustomers}/api/v1/customer-board/bind-customer-to-board`,
        method: 'post',
        data: {
          boardIds: [boardId],
          personIds: personIds,
        },
        headers: { Authorization: token },
        maxContentLength: Infinity,
        maxBodyLength: Infinity,
      });
    } catch (error) {
      return error;
    }
  } catch (error) {
    return error;
  }
};

const migrateData = async () => {
  console.info('Iniciando processo de geração de itens de trabalho');

  for (let i = 2001; i < 3000; i++) {
    const rsCreateWorkItem = await createWorkItem(i);
    if (rsCreateWorkItem.status === 200) {
      const workItemData = rsCreateWorkItem.data;
      console.info(`Ocean--> Item de trabalho ${workItemData.workItemId} criado com sucesso.`);
  
      const rsDirectoriesWorkItem = await directoriesWorkItem(
        workItemData.workItemId,
        workItemData.boardId,
        workItemData.name,
      );
  
      if (rsDirectoriesWorkItem.status === 200) {
        console.info(`Ocean Drive--> Diretório do item de trabalho ${workItemData.workItemId} criado com sucesso.`);
  
        const rsUpdateDirectory = await updateDirectory(
          workItemData.shareTaskId,
          rsDirectoriesWorkItem.data.directoryId
        );
  
        if (rsUpdateDirectory.status === 200) {
          console.info(`Ocean--> Diretório do item de trabalho ${workItemData.workItemId} atualizado com sucesso.`);
  
          const rsApplyModelWorkItem = await applyModelWorkItem(
            workItemData.shareTaskId,
            pWorkItemModelId,
          );
  
          if (rsApplyModelWorkItem.status === 200) {
            console.info(`Ocean--> Modelo aplicado no item de trabalho ${workItemData.workItemId} com sucesso.`);
  
            const rsApplyModelOceanForms = await applyModelOceanForms(
              workItemData.workItemId,
              pWorkItemModelId,
              workItemData.itemTypeId,
            );
  
            if (rsApplyModelOceanForms.status === 200) {
              console.info(`Ocean Forms--> Modelo de formulário aplicado no item de trabalho ${workItemData.workItemId} com sucesso.`);
  
              if (rsApplyModelOceanForms.data?.personIds?.length > 0) {
                const resBindCustomerToBoard = await bindCustomerToBoard(
                  pBoardId,
                  rsApplyModelOceanForms.data.personIds
                );
  
                if (resBindCustomerToBoard.status === 200) {
                  console.info(`Ocean Customers--> Clientes do formulário do item de trabalho ${workItemData.workItemId} vinculados com sucesso.`);
                } else {
                  console.error(`Ocean Customers--> Ocorreu um erro ao vincular os clientes do formulário do item de trabalho ${workItemData.workItemId}, motivo: ${e}`);
                }
              }
            } else {
              console.error(`Ocean Forms--> Ocorreu um erro ao aplicar o modelo formulário para o item de trabalho ${workItemData.workItemId}, motivo: ${e}`);
            }
          } else {
            console.error(`Ocean--> Ocorreu um erro ao aplicar o modelo no item de trabalho ${workItemData.workItemId}, motivo: ${e}`);
          }
        } else {
          console.error(`Ocean--> Ocorreu um erro ao atualizar o diretório do item de trabalho ${workItemData.workItemId}, motivo: ${e}`);
        }
      } else {
        console.error(`Ocean Drive--> Ocorreu um erro ao gerar o diretório do item de trabalho ${workItemData.workItemId}, motivo: ${e}`);
      }
    } else {
      console.error(`Ocean--> Ocorreu um erro ao gravar o item de trabalho ${workItemData.workItemId}, motivo: ${e}`);
    }
  }
};

migrateData();