AipApp/src/app.js

const cookieParser = require('cookie-parser');
const cors = require("cors");
const fs = require("fs");
const path = require("path");
const express = require("express");
const axios = require("axios");
const SERVER_PORT = process.env.port || process.env.PORT || 53000;
const authProvider = require('./auth/AuthProvider');
const {fetch, updateFetch} = require('./fetch');
const bodyParser = require('body-parser');
const https = require('https');
require('dotenv').config({ path: './env/.env.test' });
const session = require('express-session');
const messages = require('dote/src/messages');

const serverApp = express();

serverApp.use(session({
  secret: process.env.EXPRESS_SESSION_SECRET,
  resave: false,
  saveUninitialized: true,
  cookie: {
      httpOnly: true,
      secure: true, // set this to true on production
      sameSite: 'none',
      maxAge: 60 * 60 * 24 * 1000
  }
}));

serverApp.set(express.json());
serverApp.use(cookieParser());
serverApp.use(express.urlencoded({ extended: false }));
serverApp.use("/static",express.static(path.join(__dirname, 'static')));
serverApp.use("/node_modules",express.static(path.join(__dirname, 'node_modules')));

const options = {
  key: process.env.SSL_KEY_FILE ? fs.readFileSync(process.env.SSL_KEY_FILE) : undefined,
  cert: process.env.SSL_CRT_FILE ? fs.readFileSync(process.env.SSL_CRT_FILE) : undefined,
};

const server = https.createServer(options, serverApp);

const corsOption = {
  origin: "*",
}


serverApp.use(cors(corsOption));
serverApp.use(bodyParser.json());

server.listen(SERVER_PORT, function () {
  console.log(`\n${serverApp.name} listening to ${SERVER_PORT}`);
});

serverApp.get("/tab", 
  isAuthenticated, 
  async function (req, res, next) {
    res.sendFile(path.join(__dirname, "/views/hello.html"), 
      { idTokenClaims: req.session.account.idTokenClaims }
    );
  }
);

function isAuthenticated(req, res, next) {
  if (!req.session.isAuthenticated) {
    return res.redirect('/auth/signin'); // redirect to sign-in route
  }
  next();
}; 

function isAccessToken(req, res, next) {
  if (!req.session.accessToken) {
    return authProvider.acquireToken({
      scopes: ['.default'],
      redirectUri: 'https://localhost:53000/redirect',
      successRedirect: '/api-redirect'
    })(req, res, next);
  }
  next();
}

serverApp.get("/auth/signin", authProvider.login({
  scopes: ['.default'],
  redirectUri: 'https://localhost:53000/redirect',
  successRedirect: '/tab'
}))

serverApp.post("/redirect", authProvider.handleRedirect());

serverApp.post("/api-get",   
  isAuthenticated,
  isAccessToken, 
  async (req, res, next) => {
    const uri = req.body.api_uri || req.session.apiUri;
    let param = {};
    if (req.session.param) {
      param = req.session.param;
    }
    try {
        const graphResponse = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0" + uri, req.session.accessToken, param);
        res.json(graphResponse);
    } catch (error) {
        next(error);
    }
});

serverApp.get("/api-redirect", 
  isAuthenticated,
  async function (req, res, next) {
      const uri = req.session.apiUri;
      let param = {};
      if (req.session.param) {
        param = req.session.param;
      }
      try {
          const graphResponse = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0" + uri, req.session.accessToken, param);
          res.json(graphResponse);
      } catch (error) {
          next(error);
      }
})

serverApp.get("/post-redirect", 
  isAuthenticated,
  async function (req, res, next) {
    const uri = req.session.apiUri;
    let param = {};
      if (req.session.param) {
        param = req.session.param;
      }
    try {
        const graphResponse = await updateFetch(process.env.GRAPH_API_ENDPOINT + "v1.0" + uri, req.session.accessToken, param);
        res.json(graphResponse);
    } catch (error) {
        next(error);
    }
  }
)

serverApp.post("/api-update", authProvider.acquireToken({
  scopes: [],
  redirectUri: 'https://localhost:53000/redirect',
  successRedirect: '/post-redirect'
}));

serverApp.post("/api-post", authProvider.acquireToken({
  scopes: ['.default'],
  redirectUri: 'https://localhost:53000/redirect',
  successRedirect: '/post-redirect'
}));

serverApp.post("/getGroupList", authProvider.acquireToken({
  scopes: ['.default'],
  redirectUri: 'https://localhost:53000/redirect',
  successRedirect: '/group-redirect'
}));

serverApp.get("/group-redirect", 
  isAuthenticated,
  async function (req, res, next) {
    // return;
    try {
        const oneDrive = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0/me/drive/root", req.session.accessToken);
        const sharePointIds = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0/me/drive/SharePointIds", req.session.accessToken);
        // const oneDriveItems = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0/me/drive/root/children", req.session.accessToken);
        const graphResponse = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0/me/joinedTeams", req.session.accessToken);
        const sites = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0/sites/root", req.session.accessToken);
        const sitesSharePoint = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0/sites/root/SharePointIds", req.session.accessToken);

        const teams = graphResponse.value;
        oneDrive.sharePoint = sharePointIds;
        sites.sharePoint = sitesSharePoint;
        const resultObj = {
          oneDrive : {
            teams: oneDrive,
            // items: oneDriveItems.value,
          },
          joinedTeams : {
            teams : teams,
            items : {},
          },
          sites : {
            teams : sites,
            // items : {},
          },
        }
        // if (sites) {
        //   if (Array.isArray(sites)) {
        //       for(let site of sites) {
        //         const siteObj = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0/sites/"+site.id+"/drive/items/root/children", req.session.accessToken);
        //         resultObj.sites.items[site.id] = siteObj.value;
        //       }
        //   }
        //   else if (sites.id) {
        //     const sitesObj = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0/sites/"+sites.id+"/drive/items/root/children", req.session.accessToken);
        //     if (sitesObj) {
        //       resultObj.sites.items[sites.id] = sitesObj.value;
        //     }
        //   }
        // }
        if (teams && teams.length) {
          const options = {
            responseType: 'arraybuffer',
            headers: {
              Authorization: `Bearer ${req.session.accessToken}`,
              ConsistencyLevel: 'eventual',
            },
          };
          for (let team of teams) {
            const item = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0/groups/"+team.id+"/drive/items/root/children", req.session.accessToken);
            const sharePoint = await fetch(process.env.GRAPH_API_ENDPOINT + "v1.0/groups/"+team.id+"/drive/SharePointIds", req.session.accessToken);
            if (sharePoint) {
              team.sharePoint = sharePoint;
            }
            if (item && item.value) {
              resultObj.joinedTeams.items[team.id] = item.value;
            }
          }
        }
        res.json(resultObj);
    } catch (error) {
        next(error);
    } 
  }
)

serverApp.post('/makeFolder', 
    isAuthenticated,
    (req, res, next)=>{
      if (!req.session.accessToken) {
        return authProvider.acquireToken({
          scopes: ['.default'],
          redirectUri: 'https://localhost:53000/redirect',
          successRedirect: '/makeFolder'
        })(req, res, next);
      }
      next();
    },
    async (req, res, next)=>{

      const options = {
        headers: {
          Authorization: `Bearer ${req.session.accessToken}`,
        },
      };
      const {siteId, path, param} = req.body;
      try{
        const sitesInfo = await axios.get(process.env.GRAPH_API_ENDPOINT + "v1.0/sites/"+ siteId + path, options);
        if (sitesInfo.data) {
          const itemId = sitesInfo.data.id;
          const result = await axios.post(process.env.GRAPH_API_ENDPOINT + "v1.0/sites/"+ siteId +"/drive/items/" + itemId +"/children", JSON.parse(param), options);
          res.json(result.data)
        }
      }
      catch(error) {
        console.log(error.response.data.error); 
        
        // resultObj.success = 'F';
        // resultObj.message = '선택하신 파일 정보 삭제중 오류가 발생하였습니다.\n' + error.response.data.error.message;
        // return res.json(resultObj);
      }
})

serverApp.post('/uploadItems', 
  isAuthenticated,
  (req, res, next)=>{
    if (!req.session.accessToken) {
      return authProvider.acquireToken({
        scopes: ['.default'],
        redirectUri: 'https://localhost:53000/redirect',
        successRedirect: '/uploadItems'
      })(req, res, next);
    }
    next();
  },
  async (req, res, next)=>{
    if (req.body) {
      const {siteId, path, param} = req.body;
      if (siteId && param) {
        const options = {
          headers: {
            Authorization: `Bearer ${req.session.accessToken}`,
          },
        };

        const sitesInfo = await axios.get(process.env.GRAPH_API_ENDPOINT + "v1.0/sites/"+ siteId + path, options);
        if (sitesInfo.data) {
          const itemId = sitesInfo.data.id;
          const fileInfo = JSON.parse(param);
          const result = await axios.post(process.env.GRAPH_API_ENDPOINT + "v1.0/sites/"+ siteId +"/drive/items/"+itemId+':/'+fileInfo.name+':/content', fileInfo, options);
          res.json(result.data);
        }

      }
    }
})

serverApp.post('/deleteItems', 
  isAuthenticated,
  (req, res, next)=>{
    if (!req.session.accessToken) {
      return authProvider.acquireToken({
        scopes: ['.default'],
        redirectUri: 'https://localhost:53000/redirect',
        successRedirect: '/deleteItems'
      })(req, res, next);
    }
    next();
  },
  async (req, res, next)=>{
    if (req.body) {
      const {siteId, itemIds} = req.body;
      const resultObj = {success: '', message:''};
      if (siteId && itemIds) {
        const itemIdArr = JSON.parse(itemIds);
        if (itemIdArr.length > 0) {
          const options = {
            headers: {
              Authorization: `Bearer ${req.session.accessToken}`,
            },
          };
          for (let itemId of itemIdArr) {
            try{
              await axios.delete(process.env.GRAPH_API_ENDPOINT + "v1.0/sites/"+ siteId + "/drive/items/" + itemId, options);
            }
            catch(error) {
              console.log(error.response.data.error); 
              
              resultObj.success = 'F';
              resultObj.message = '선택하신 파일 정보 삭제중 오류가 발생하였습니다.\n' + error.response.data.error.message;
              return res.json(resultObj);
            }
          }
          resultObj.success = 'S';
          resultObj.message = '파일 정보가 삭제되었습니다.';
          res.json(resultObj);
        }
      }
      else {
        resultObj.success = 'F';
        resultObj.message = '파라미터 정보를 확인해주세요.';
        res.json(resultObj);
      }
    }
  })